11/01/2024

Consolidated the Multitargeting Analysis and Population Analysis modules. Addressed various bug fixes to improve functionality and user experience.

Hypothesis

If the Multitargeting Analysis and Population Analysis modules are consolidated, users will be able to use these functionalities in CASPER.

If the bugs are resolved, users will be able to operate the program without experiencing crashes.

Expected Results

Results

Bugs Fixed

Special thanks to David for stress-testing the program last week. The following issues have been resolved:

Next Steps

My next step is to address any bugs that David may encounter during testing. I’ll focus on stabilizing the modules with outstanding issues and proceed with the implementation of the Microbiome Analysis module.

Files changed (38) hide show

src/controllers/FindTargetsController.py +93 -25
src/controllers/HomeWindowController.py +26 -6
src/controllers/MainWindowController.py +20 -30
src/controllers/MultitargetingWindowController.py +244 -55
src/controllers/NCBIWindowController.py +17 -117
src/controllers/NewEndonucleaseController.py +0 -1
src/controllers/PopulatioAnalysisWindowController.py +0 -0
src/controllers/PopulationAnalysisWindowController.py +130 -32
src/controllers/ViewTargetsController.py +129 -15
src/models/AnnotationParser.py +130 -36
src/models/CSPRparser.py +121 -19
src/models/DatabaseManager.py +290 -3
src/models/FindTargetsModel.py +62 -28
src/models/GlobalSettings.py +17 -0
src/models/MultitargetingWindowModel.py +105 -113
src/models/NCBIWindowModel.py +120 -0
src/models/NewGenomeWindowModel.py +2 -2
src/models/PopulationAnalysisWindowModel.py +84 -30
src/models/ViewTargetsModel.py +268 -147
src/ui/multitargeting_window.ui +54 -214
src/ui/ncbi_window_v2.ui +0 -10
src/ui/{pop.ui → population_analysis.ui} +134 -270
src/utils/ui.py +8 -19
src/views/AnnotationParser.py +0 -429
src/views/CMainWindow.py +0 -987
src/views/FindTargetsView.py +55 -32
src/views/HomeWindowView.py +3 -0
src/views/MainWindowView.py +208 -51
src/views/MultitargetingWindowView.py +342 -80
src/views/NCBIRenameWindowView.py +3 -1
src/views/NCBIWindowView.py +90 -48
src/views/NewEndonuclease.py +0 -228
src/views/NewGenome.py +0 -705
src/views/PopulationAnalysisWindowView.py +114 -108
src/views/ViewTargetsView.py +48 -9
src/views/closingWin.py +0 -73
src/views/export_tool.py +0 -259
src/views/generateLib.py +0 -662

src/controllers/FindTargetsController.py CHANGED Viewed

@@ -1,45 +1,113 @@
 from models.FindTargetsModel import FindTargetsModel
 from views.FindTargetsView import FindTargetsView
 from PyQt6.QtWidgets import QMessageBox
 class FindTargetsController:
     def __init__(self, global_settings):
         self.global_settings = global_settings
-        self.model = FindTargetsModel(global_settings)
-        self.view = FindTargetsView(global_settings)
-        self._connect_signals()
         self.organism = None
         self.endonuclease = None
     def _connect_signals(self):
-        self.view.push_button_view_targets.clicked.connect(self.view_targets)
     def find_targets(self, input_data):
         try:
-            self.global_settings.logger.debug(f"FindTargetsController received input data: {input_data}")
             self.organism = input_data['organism']
             self.endonuclease = input_data['endonuclease']
             results = self.model.find_targets(input_data)
-            self.global_settings.logger.debug(f"Find targets results: {results}")
-            self.view.display_results(results)
-        except ValueError as e:
-            error_message = str(e)
-            QMessageBox.critical(self.view, "Error", error_message)
-            self.global_settings.logger.error(f"ValueError in find_targets: {error_message}")
         except Exception as e:
-            error_message = f"An unexpected error occurred while finding targets: {str(e)}"
-            QMessageBox.critical(self.view, "Error", error_message)
-            self.global_settings.logger.error(f"Unexpected error in find_targets: {str(e)}", exc_info=True)
     def view_targets(self):
-        selected_targets = self.view.get_selected_targets()
-        if not selected_targets:
-            QMessageBox.warning(self.view, "No Selection", "Please select targets to view.")
-            return
-        view_targets_controller = self.global_settings.get_view_targets_window()
-        view_targets_controller.load_targets(selected_targets, self.organism, self.endonuclease)
-        self.global_settings.main_window.open_new_tab("View Targets", view_targets_controller)
-    def show(self):
-        self.view.show()

 from models.FindTargetsModel import FindTargetsModel
 from views.FindTargetsView import FindTargetsView
 from PyQt6.QtWidgets import QMessageBox
+from PyQt6.QtCore import QTimer
 class FindTargetsController:
     def __init__(self, global_settings):
         self.global_settings = global_settings
+        self.model = None
+        self.view = None
         self.organism = None
         self.endonuclease = None
+        self._input_data = None
+        self._current_annotation_file = None
+        # Connect to annotation file changes
+        self.global_settings.annotation_file_changed.connect(self._on_annotation_file_changed)
+    def _on_annotation_file_changed(self, new_annotation_file):
+        """Handle annotation file changes by reprocessing data"""
+        try:
+            self.global_settings.logger.debug(f"FindTargetsController received new annotation file: {new_annotation_file}")
+            self._current_annotation_file = new_annotation_file
+            # Clear existing view and model
+            self.view = None
+            self.model = None
+        except Exception as e:
+            self.global_settings.logger.error(f"Error handling annotation file change: {str(e)}")
     def _connect_signals(self):
+        """Connect view signals"""
+        if self.view:
+            self.view.push_button_view_targets.clicked.connect(self.view_targets)
     def find_targets(self, input_data):
+        """Initialize view and process input data"""
         try:
+            # Get current annotation file
+            current_annotation = self.global_settings.get_current_annotation_file()
+            input_data['annotation_file'] = current_annotation
+            self._current_annotation_file = current_annotation
+            # Always create new instances
+            self.model = FindTargetsModel(self.global_settings)
+            self.view = FindTargetsView(self.global_settings)
+            self._connect_signals()
+            self._input_data = input_data
+            # Find existing Find Targets tab
+            main_window = self.global_settings.main_window
+            existing_tab = main_window.find_tab_by_title("Find Targets")
+            if existing_tab:
+                # Remove the existing tab
+                tab_index = main_window.view.tab_widget.indexOf(existing_tab)
+                main_window.view.tab_widget.removeTab(tab_index)
+            # Process data and create new tab
+            self._process_input_data(input_data)
+        except Exception as e:
+            self.global_settings.logger.error(f"Error in find_targets: {str(e)}")
+            raise
+    def _process_input_data(self, input_data):
+        """Process input data and update view"""
+        try:
+            if not self.view:
+                return
+            self.global_settings.logger.debug(f"FindTargetsController processing input data: {input_data}")
             self.organism = input_data['organism']
             self.endonuclease = input_data['endonuclease']
+            # Get new results
             results = self.model.find_targets(input_data)
+            self.global_settings.logger.debug(f"Found {len(results) if results else 0} targets")
+            # Update view with new results
+            if results:
+                self.view.display_results(results)
+            # Add new tab with updated view
+            main_window = self.global_settings.main_window
+            main_window.open_new_tab("Find Targets", self)
         except Exception as e:
+            self.global_settings.logger.error(f"Error processing input data: {str(e)}")
+            if self.view:
+                QMessageBox.critical(self.view, "Error", f"An error occurred while processing data: {str(e)}")
     def view_targets(self):
+        """Handle view targets button click"""
+        try:
+            if not self.view:
+                return
+            selected_targets = self.view.get_selected_targets()
+            if not selected_targets:
+                QMessageBox.warning(self.view, "No Selection", "Please select targets to view.")
+                return
+            view_targets_controller = self.global_settings.get_view_targets_window()
+            view_targets_controller.load_targets(selected_targets, self.organism, self.endonuclease)
+            self.global_settings.main_window.open_new_tab("View Targets", view_targets_controller)
+        except Exception as e:
+            self.global_settings.logger.error(f"Error in view_targets: {str(e)}")
+            if self.view:
+                QMessageBox.critical(self.view, "Error", f"An error occurred while viewing targets: {str(e)}")

src/controllers/HomeWindowController.py CHANGED Viewed

@@ -78,6 +78,9 @@ class HomeWindowController:
             self.view.push_button_find_targets.clicked.connect(self.gather_settings)
             self.view.push_button_view_targets.clicked.connect(self.view_results)
             self.view.push_button_generate_library.clicked.connect(self.prep_gen_lib)
         except Exception as e:
             show_error(self.global_settings, "Error setting up connections in HomeWindowController", str(e))
@@ -134,17 +137,27 @@ class HomeWindowController:
     def open_multitargeting_analysis_module(self):
         try:
-            multitargeting_controller = self.global_settings.get_multitargeting_window()
-            multitargeting_window = multitargeting_controller.view
-            self.global_settings.main_window.open_new_tab("Multitargeting Analysis", multitargeting_window)
         except Exception as e:
             show_error(self.global_settings, "Error in open_multitargeting_analysis_widget() in Home", str(e))
     def open_population_analysis_module(self):
         try:
-            population_analysis_controller = self.global_settings.get_population_analysis_window()
-            population_analysis_window = population_analysis_controller.view
-            self.global_settings.main_window.open_new_tab("Population Analysis", population_analysis_window)
         except Exception as e:
             show_error(self.global_settings, "Error in open_population_analysis_widget() in Home", str(e))
@@ -198,4 +211,11 @@ class HomeWindowController:
     def get_annotation_files(self):
         return self.model.get_annotation_files()

             self.view.push_button_find_targets.clicked.connect(self.gather_settings)
             self.view.push_button_view_targets.clicked.connect(self.view_results)
             self.view.push_button_generate_library.clicked.connect(self.prep_gen_lib)
+            # Add connection for annotation file changes
+            self.view.combo_box_local_annotation_files.currentTextChanged.connect(self._on_annotation_file_changed)
         except Exception as e:
             show_error(self.global_settings, "Error setting up connections in HomeWindowController", str(e))
     def open_multitargeting_analysis_module(self):
         try:
+            main_window = self.global_settings.main_window
+            existing_tab = main_window.find_tab_by_title("Multitargeting Analysis")
+            if existing_tab:
+                main_window.view.tab_widget.setCurrentWidget(existing_tab)
+                main_window._resize_for_tab("Multitargeting Analysis")
+            else:
+                multitargeting_controller = self.global_settings.get_multitargeting_window()
+                main_window.open_new_tab("Multitargeting Analysis", multitargeting_controller)
         except Exception as e:
             show_error(self.global_settings, "Error in open_multitargeting_analysis_widget() in Home", str(e))
     def open_population_analysis_module(self):
         try:
+            main_window = self.global_settings.main_window
+            existing_tab = main_window.find_tab_by_title("Population Analysis")
+            if existing_tab:
+                main_window.view.tab_widget.setCurrentWidget(existing_tab)
+                main_window._resize_for_tab("Population Analysis")
+            else:
+                population_analysis_controller = self.global_settings.get_population_analysis_window()
+                main_window.open_new_tab("Population Analysis", population_analysis_controller)
         except Exception as e:
             show_error(self.global_settings, "Error in open_population_analysis_widget() in Home", str(e))
     def get_annotation_files(self):
         return self.model.get_annotation_files()
+    def get_annotation_file(self):
+        return self.view.get_annotation_file()
+    def _on_annotation_file_changed(self, new_file):
+        """Handle changes to the annotation file selection"""
+        self.global_settings.set_current_annotation_file(new_file)

src/controllers/MainWindowController.py CHANGED Viewed

@@ -17,14 +17,12 @@ class MainWindowController:
         self.tab_widgets = {}  # Store references to tab widgets
         self.startup_controller = None
         self.is_first_time_startup = self.global_settings.is_first_time_startup
-        self.tab_sizes = {
-            "Startup": QSize(750, 550),
-            "New Genome": QSize(575, 700),
-            "Home": QSize(1000, 700),  # Add a default size for Home tab
-            "Define New Endonuclease": QSize(450, 600),
-            "NCBI Download Tool": QSize(1000, 700),
-            "View Targets": QSize(1500, 700),
-        }
         self.current_tab = None
         try:
@@ -244,25 +242,16 @@ class MainWindowController:
         self.view.tab_widget.currentChanged.connect(self._on_tab_changed)
     def _resize_for_tab(self, title):
-        if title in self.tab_sizes:
-            new_size = self.tab_sizes[title]
-            if title == "Startup":
-                # For Startup tab, set fixed size and disable maximize button
-                self.view.setFixedSize(new_size)
-                self.view.setWindowFlags(self.view.windowFlags() & ~Qt.WindowType.WindowMaximizeButtonHint)
-            else:
-                # For other tabs, allow resizing but set a minimum size
-                self.view.setMinimumSize(QSize(400, 300))  # Set a reasonable minimum size
-                self.view.setMaximumSize(QtCore.QSize(16777215, 16777215))
-                self.view.setWindowFlags(self.view.windowFlags() | Qt.WindowType.WindowMaximizeButtonHint)
-                # Resize to the specified size for the tab
-                self.view.resize(new_size)
         else:
-            # Default behavior for unknown tabs
-            self.view.setMinimumSize(QSize(400, 300))  # Set a reasonable minimum size
             self.view.setMaximumSize(QtCore.QSize(16777215, 16777215))
             self.view.setWindowFlags(self.view.windowFlags() | Qt.WindowType.WindowMaximizeButtonHint)
         # Ensure window flags are updated
         self.view.show()
@@ -349,16 +338,15 @@ class MainWindowController:
         return None
     def _on_tab_changed(self, index):
-        # Save the current tab size before switching
-        if self.current_tab:
             current_size = self.view.size()
             if current_size.width() >= 400 and current_size.height() >= 300:
-                self.tab_sizes[self.current_tab] = current_size
-        # Get the new tab title
         new_tab_title = self.view.tab_widget.tabText(index)
-        # Resize for the new tab
         self._resize_for_tab(new_tab_title)
     def close_new_genome_and_switch_to_home(self):
@@ -391,3 +379,5 @@ class MainWindowController:
             show_error(self.global_settings, "Error switching to Home tab", str(e))

         self.tab_widgets = {}  # Store references to tab widgets
         self.startup_controller = None
         self.is_first_time_startup = self.global_settings.is_first_time_startup
+        # Single shared size for all regular tabs
+        self.shared_tab_size = QSize(850, 850)
+        # Separate size only for startup
+        self.startup_size = QSize(750, 550)
         self.current_tab = None
         try:
         self.view.tab_widget.currentChanged.connect(self._on_tab_changed)
     def _resize_for_tab(self, title):
+        if title == "Startup":
+            # For Startup tab, set fixed size and disable maximize button
+            self.view.setFixedSize(self.startup_size)
+            self.view.setWindowFlags(self.view.windowFlags() & ~Qt.WindowType.WindowMaximizeButtonHint)
         else:
+            # For all other tabs, use the shared size and allow resizing
+            self.view.setMinimumSize(QSize(400, 300))
             self.view.setMaximumSize(QtCore.QSize(16777215, 16777215))
             self.view.setWindowFlags(self.view.windowFlags() | Qt.WindowType.WindowMaximizeButtonHint)
+            self.view.resize(self.shared_tab_size)
         # Ensure window flags are updated
         self.view.show()
         return None
     def _on_tab_changed(self, index):
+        # Save the current size before switching if it's not the startup tab
+        if self.current_tab and self.current_tab != "Startup":
             current_size = self.view.size()
             if current_size.width() >= 400 and current_size.height() >= 300:
+                # Update shared size for all non-startup tabs
+                self.shared_tab_size = current_size
+        # Get the new tab title and resize
         new_tab_title = self.view.tab_widget.tabText(index)
         self._resize_for_tab(new_tab_title)
     def close_new_genome_and_switch_to_home(self):
             show_error(self.global_settings, "Error switching to Home tab", str(e))

src/controllers/MultitargetingWindowController.py CHANGED Viewed

@@ -1,67 +1,256 @@
 from PyQt6.QtWidgets import QMainWindow
 from views.MultitargetingWindowView import MultitargetingWindowView
 from models.MultitargetingWindowModel import MultitargetingWindowModel
 class MultitargetingWindowController(QMainWindow):
     def __init__(self, global_settings):
         super().__init__()
-        self.global_settings = global_settings
-        self._view = MultitargetingWindowView(global_settings)
-        self._model = MultitargetingWindowModel(global_settings)
-        self.setCentralWidget(self._view)
-        self.setup_connections()
-    @property
-    def view(self):
-        return self._view
-    @property
-    def model(self):
-        return self._model
-    def show(self):
-        super().show()
-    def setup_connections(self):
-        # Connect signals from view to controller methods
-        self.view.comboBox_organism.currentIndexChanged.connect(self.update_endo_list)
-        self.view.comboBox_endo.currentIndexChanged.connect(self.load_data)
-        self.view.pushButton_load.clicked.connect(self.load_data)
-        # Add more connections as needed
-    def update_endo_list(self):
-        organism = self.view.comboBox_organism.currentText()
-        endos = self.model.get_endos_for_organism(organism)
-        self.view.comboBox_endo.clear()
-        self.view.comboBox_endo.addItems(endos)
-    def load_data(self):
-        organism = self.view.comboBox_organism.currentText()
-        endo = self.view.comboBox_endo.currentText()
-        self.model.set_files(organism, endo)
-        # Load and process data
-        repeats_data = self.model.get_repeats_data()
-        kstats = self.model.get_kstats()
-        # Update view with data
-        self.view.update_table(repeats_data)
-        self.view.update_global_stats(self.model)
-        # Load and update graphs
-        self.load_graphs()
-    def load_graphs(self):
-        # Load data for graphs
-        seeds_vs_repeats = self.model.get_seeds_vs_repeats_data()
-        repeats_vs_seeds = self.model.get_repeats_vs_seeds_data()
-        # Update graphs in view
-        self.view.update_global_line_graph(seeds_vs_repeats)
-        self.view.update_global_bar_graph(repeats_vs_seeds)
-    def initialize(self):
-        organisms = self.model.get_organisms()
-        self.view.comboBox_organism.addItems(organisms)
-        self.view.scaleUI()
-        self.view.centerUI()

 from PyQt6.QtWidgets import QMainWindow
 from views.MultitargetingWindowView import MultitargetingWindowView
 from models.MultitargetingWindowModel import MultitargetingWindowModel
+from utils.ui import show_error
 class MultitargetingWindowController(QMainWindow):
     def __init__(self, global_settings):
         super().__init__()
+        self.settings = global_settings
+        self.logger = global_settings.get_logger()
+        try:
+            self._model = MultitargetingWindowModel(global_settings)
+            self._view = MultitargetingWindowView(global_settings)
+            self.setCentralWidget(self._view)
+            self._init_ui()
+            self._setup_connections()
+        except Exception as e:
+            show_error(self.settings, "Error initializing MultitargetingWindowController", str(e))
+    def _init_ui(self):
+        """Initialize UI components"""
+        try:
+            # Set up initial data
+            organisms = self._model.get_organisms()
+            self._view.combo_box_organism.clear()
+            self._view.combo_box_organism.addItems(organisms)
+            # If we have organisms, trigger the first one
+            if organisms:
+                self._on_organism_changed(0)
+            # Initialize plots
+            self._view.setup_plots()
+        except Exception as e:
+            self.logger.error(f"Error in _init_ui: {str(e)}")
+            show_error(self.settings, "Error", f"Failed to initialize UI: {str(e)}")
+    def _setup_connections(self):
+        """Set up signal-slot connections"""
+        # Organism and endonuclease selection
+        self._view.combo_box_organism.currentIndexChanged.connect(self._on_organism_changed)
+        self._view.combo_box_endonuclease.currentIndexChanged.connect(self._on_endonuclease_changed)
+        # Buttons
+        self._view.push_button_analyze.clicked.connect(self._on_analyze_clicked)
+        self._view.push_button_statistics_overview.clicked.connect(self._on_statistics_overview_clicked)
+        self._view.tool_button_sql_settings.clicked.connect(self._on_sql_settings_clicked)
+        # Table selection
+        self._view.table_seeds.itemSelectionChanged.connect(self._on_seed_selected)
+        self._view.check_box_select_all.stateChanged.connect(self._on_select_all_changed)
+    def _on_organism_changed(self, index):
+        """Handle organism selection change"""
+        try:
+            organism = self._view.combo_box_organism.currentText()
+            if not organism:
+                return
+            # Get endos for selected organism
+            endos = self._model.get_endos_for_organism(organism)
+            # Update endonuclease combo box
+            self._view.combo_box_endonuclease.clear()
+            self._view.combo_box_endonuclease.addItems(endos)
+            # Update file paths
+            if endos:
+                self._model.set_files(organism, endos[0])
+        except Exception as e:
+            self.logger.error(f"Error in _on_organism_changed: {str(e)}")
+            show_error(self.settings, "Error", f"Failed to update endonucleases: {str(e)}")
+    def _on_endonuclease_changed(self, index):
+        """Handle endonuclease selection change"""
+        self._update_analysis_button_state()
+    def _on_analyze_clicked(self):
+        """Handle analyze button click"""
+        try:
+            organism = self._view.combo_box_organism.currentText()
+            endo = self._view.combo_box_endonuclease.currentText()
+            if not organism or not endo:
+                show_error(self.settings, "Analysis Error", "Please select both an organism and an endonuclease.")
+                return
+            # Load data
+            try:
+                self._model.set_files(organism, endo)
+            except FileNotFoundError as e:
+                show_error(self.settings, "File Error",
+                          f"Could not find required files for {organism} with {endo}. Please ensure the files exist.")
+                return
+            except ValueError as e:
+                show_error(self.settings, "Input Error", str(e))
+                return
+            seeds_data = self._model.get_repeats_data()
+            # Update UI
+            self._view.update_seeds_table(seeds_data)
+            self._update_plots()
+        except Exception as e:
+            show_error(self.settings, "Analysis Error", str(e))
+    def _on_statistics_overview_clicked(self):
+        """Handle statistics overview button click"""
+        try:
+            stats = self._model.calculate_statistics()
+            self._show_statistics_dialog(stats)
+        except Exception as e:
+            show_error(self.settings, "Statistics Error", str(e))
+    def _on_sql_settings_clicked(self):
+        """Handle SQL settings button click"""
+        try:
+            current_settings = self._model.get_sql_settings()
+            if self._show_sql_settings_dialog(current_settings):
+                new_settings = self._get_sql_settings_from_dialog()
+                self._model.update_sql_settings(new_settings)
+        except Exception as e:
+            show_error(self.settings, "SQL Settings Error", str(e))
+    def _on_seed_selected(self):
+        """Handle seed selection in table"""
+        try:
+            selected_items = self._view.table_seeds.selectedItems()
+            if selected_items:
+                row = selected_items[0].row()
+                seed = self._view.table_seeds.item(row, 0).text()
+                # Get seed data
+                seed_data = self._model.get_seed_data(seed)
+                if not seed_data:
+                    return
+                # Process seed data for visualization
+                kstats = self._model.get_kstats()
+                seed_data_processed, event_data = self._process_seed_data(seed_data, kstats)
+                # Update chromosome viewer
+                self._view.fill_chromosome_viewer(seed_data_processed, event_data)
+                # Update only the chromosome bar plot
+                chromosome_data = self._model.get_chro_bar_data(seed)
+                # Update only the chromosome plot, keep other plots unchanged
+                self._view._update_repeat_vs_chromosome_plot(chromosome_data)
+        except Exception as e:
+            self.logger.error(f"Error handling seed selection: {str(e)}")
+            show_error(self.settings, "Error", f"Failed to display seed data: {str(e)}")
+    def _process_seed_data(self, seed_data, kstats):
+        """Process seed data for visualization"""
+        try:
+            seed_data_processed = {}
+            event_data = {}
+            for data in seed_data:
+                # Split chromosome and location strings into lists
+                chromos = [int(x) for x in data[0].split(',')]
+                locs = [int(x) for x in data[1].split(',')]
+                pams = data[2].split(',')
+                scores = data[3].split(',')
+                fives = data[4].split(',')
+                threes = data[5].split(',')
+                # Process each chromosome location
+                for i in range(len(chromos)):
+                    chromo = chromos[i]
+                    pos = locs[i]
+                    # Normalize location
+                    dir = "+" if pos >= 0 else "-"
+                    normalized_location = abs(float(pos) / float(kstats[chromo - 1]))
+                    # Store data
+                    if chromo in seed_data_processed:
+                        seed_data_processed[chromo].append(normalized_location)
+                        event_data[chromo].append([
+                            normalized_location,
+                            pos,
+                            fives[i] + threes[i],
+                            pams[i],
+                            scores[i],
+                            dir
+                        ])
+                    else:
+                        seed_data_processed[chromo] = [normalized_location]
+                        event_data[chromo] = [[
+                            normalized_location,
+                            pos,
+                            fives[i] + threes[i],
+                            pams[i],
+                            scores[i],
+                            dir
+                        ]]
+            return seed_data_processed, event_data
+        except Exception as e:
+            self.logger.error(f"Error processing seed data: {str(e)}")
+            raise
+    def _on_select_all_changed(self, state):
+        """Handle select all checkbox state change"""
+        self._view.table_seeds.selectAll() if state else self._view.table_seeds.clearSelection()
+    def _update_analysis_button_state(self):
+        """Update analyze button enabled state"""
+        has_organism = bool(self._view.organism_drop.currentText())
+        has_endo = bool(self._view.combo_box_endonuclease.currentText())
+        self._view.push_button_analyze.setEnabled(has_organism and has_endo)
+        # Clear any existing data if selection changes
+        if not (has_organism and has_endo):
+            self._view.table_seeds.setRowCount(0)
+            self._view.update_plots(None, None, None)
+    def _update_plots(self):
+        """Update all plots with current data"""
+        try:
+            # Get repeats vs seeds data first
+            repeats_data = self._model.get_repeats_vs_seeds_data()
+            # Get sequences vs repeats data
+            sequences_data = self._model.get_seeds_vs_repeats_data()
+            # Update all plots at once
+            self._view.update_plots(repeats_data, sequences_data, None)  # chromosome_data will be updated on seed selection
+        except Exception as e:
+            self.logger.error(f"Error in _update_plots: {str(e)}")
+            show_error(self.settings, "Plot Update Error", str(e))
+    def _show_statistics_dialog(self, stats):
+        """Show statistics overview dialog"""
+        # Implement statistics dialog display
+        pass
+    def _show_sql_settings_dialog(self, current_settings):
+        """Show SQL settings dialog"""
+        # Implement SQL settings dialog display
+        return False
+    def _get_sql_settings_from_dialog(self):
+        """Get settings from SQL settings dialog"""
+        # Implement getting settings from dialog
+        return {}

src/controllers/NCBIWindowController.py CHANGED Viewed

@@ -18,18 +18,22 @@ class NCBIWindowController:
             self.model = NCBIWindowModel(settings)
             self.view = NCBIWindowView(settings)
             self._init_ui()
-            self.setup_connections()
         except Exception as e:
             show_error(self.settings, "Error initializing NCBIWindowController", str(e))
     def setup_connections(self):
         try:
             self.view.push_button_search.clicked.connect(self.search_ncbi)
             self.view.push_button_download_files.clicked.connect(self.download_files_wrapper)
             self.view.check_box_select_all_rows.clicked.connect(self.select_all_rows_in_table)
             self.view.radio_button_collections_genbank.toggled.connect(self.is_checked_GenBank_radio_button)
         except Exception as e:
             self.logger.error(f"Error setting up connections: {str(e)}", exc_info=True)
             show_error(self.settings, "Error setting up connections", str(e))
@@ -135,7 +139,9 @@ class NCBIWindowController:
                     self.on_thread_completed()  # Increment completed threads for unavailable files
                     continue
-                downloader = DownloadThread(self, url, id, species_name, strain, self.view.check_box_file_types_fna.isChecked(), self.view.check_box_file_types_gbff.isChecked())
                 downloader.finished.connect(self.on_download_finished)
                 downloader.progress_updated.connect(self.update_progress)
                 downloader.status_updated.connect(self.update_status)
@@ -165,7 +171,7 @@ class NCBIWindowController:
                 self.rename_files(self.model.files)
             elif not self.unavailable_files:
                 show_message(12, QtWidgets.QMessageBox.Icon.Warning, "No Files Downloaded", "No files were downloaded. Please check your selection and try again.")
     def show_unavailable_files_warning(self):
         warning_text = "The following files were not available for download:\n\n"
         for species_name, strain in self.unavailable_files:
@@ -209,22 +215,18 @@ class NCBIWindowController:
     def on_rename_complete(self):
         try:
-            # self.update_main_window()
             self.view.set_download_files_status_label("Download and renaming complete.<br>Press Back to go back to the Main window.")
         except Exception as e:
             self.logger.error(f"Error in on_rename_complete: {str(e)}", exc_info=True)
             show_error(self.settings, "Error after renaming", str(e))
-    def update_main_window(self):
-        try:
-            if hasattr(self.main_window, 'fill_annotation_dropdown'):
-                self.main_window.fill_annotation_dropdown()
-            else:
-                self.logger.warning("MainWindowController does not have fill_annotation_dropdown method")
-        except Exception as e:
-            self.logger.error(f"Error updating main window: {str(e)}", exc_info=True)
-            show_error(self.settings, "Error updating main window", str(e))
     def select_all_rows_in_table(self):
         if self.view.check_box_select_all_rows.isChecked():
             self.view.table_ncbi_results.selectAll()
@@ -239,105 +241,3 @@ class NCBIWindowController:
             show_message("Warning!",
                          "The GenBank collection may contain poorly or partially annotated annotation files. "
                          "We highly recommend using the RefSeq collection if it is available.")
-class DownloadThread(QtCore.QThread):
-    finished = QtCore.pyqtSignal(bool)
-    progress_updated = QtCore.pyqtSignal(int, int, int)
-    status_updated = QtCore.pyqtSignal(str)
-    all_completed = QtCore.pyqtSignal()  # New signal to indicate all operations are complete
-    def __init__(self, controller, url, id, species_name, strain, download_fna, download_gbff):
-        super().__init__()
-        self.controller = controller
-        self.url = url
-        self.id = id
-        self.species_name = species_name
-        self.strain = strain
-        self.download_fna = download_fna
-        self.download_gbff = download_gbff
-    def run(self):
-        try:
-            parsed_url = urlparse(self.url)
-            ftp_host = parsed_url.netloc
-            ftp_path = parsed_url.path
-            self.controller.logger.info(f"Attempting to connect to FTP server: {ftp_host}")
-            # Resolve the IP address
-            try:
-                ip_address = socket.gethostbyname(ftp_host)
-                self.controller.logger.info(f"Resolved IP address: {ip_address}")
-            except socket.gaierror as e:
-                self.controller.logger.error(f"Failed to resolve hostname: {ftp_host}. Error: {str(e)}")
-                self.finished.emit(False)
-                return
-            ftp = FTP(ftp_host)
-            ftp.login()
-            ftp.cwd(ftp_path)
-            ftp.set_pasv(True)  # Use passive mode
-            ftp.voidcmd('TYPE I')  # Set binary mode
-            self.controller.logger.info(f"Successfully connected to FTP server: {ftp_host}")
-            files_to_download = []
-            if self.download_fna:
-                fna_files = [f for f in ftp.nlst() if f.endswith('_genomic.fna.gz')]
-                self.controller.logger.info(f"Found {len(fna_files)} FNA files")
-                files_to_download.extend(fna_files)
-            if self.download_gbff:
-                gbff_files = [f for f in ftp.nlst() if f.endswith('_genomic.gbff.gz')]
-                self.controller.logger.info(f"Found {len(gbff_files)} GBFF files")
-                files_to_download.extend(gbff_files)
-            self.controller.logger.info(f"Total files to download: {len(files_to_download)}")
-            total_size = 0
-            for file in files_to_download:
-                try:
-                    total_size += ftp.size(file)
-                except Exception as e:
-                    self.controller.logger.warning(f"Could not get size for file {file}: {str(e)}")
-            downloaded_size = 0
-            for file in files_to_download:
-                self.status_updated.emit(f"Downloading: {file}")
-                file_type = 'FNA' if file.endswith('.fna.gz') else 'GBFF'
-                output_dir = os.path.join(self.controller.settings.CSPR_DB, file_type)
-                # Create the output directory if it doesn't exist
-                os.makedirs(output_dir, exist_ok=True)
-                local_filename = os.path.join(output_dir, file)
-                self.controller.logger.info(f"Downloading file: {file} to {local_filename}")
-                with open(local_filename, 'wb') as local_file:
-                    def callback(data):
-                        local_file.write(data)
-                        nonlocal downloaded_size
-                        downloaded_size += len(data)
-                        if total_size > 0:
-                            self.progress_updated.emit(self.id, downloaded_size, total_size)
-                    ftp.retrbinary(f"RETR {file}", callback)
-                self.controller.logger.info(f"Download complete: {file}")
-                self.status_updated.emit(f"Decompressing: {file}")
-                # Decompress the file
-                self.controller.model.decompress_file(local_filename)
-                # Add the decompressed file to the model's files list
-                decompressed_filename = local_filename[:-3]  # Remove .gz extension
-                self.controller.model.add_downloaded_file(decompressed_filename)
-            ftp.quit()
-            self.controller.logger.info(f"All files downloaded and decompressed successfully for ID: {self.id}")
-            self.all_completed.emit()  # Emit the new signal when everything is done
-            self.finished.emit(True)
-        except Exception as e:
-            self.controller.logger.error(f"Download error for ID {self.id}: {str(e)}", exc_info=True)
-            self.finished.emit(False)

             self.model = NCBIWindowModel(settings)
             self.view = NCBIWindowView(settings)
+            # Connect to the initialization complete signal
+            self.view.initialization_complete.connect(self.setup_connections)
             self._init_ui()
         except Exception as e:
             show_error(self.settings, "Error initializing NCBIWindowController", str(e))
     def setup_connections(self):
+        """Set up connections after UI is fully initialized"""
         try:
             self.view.push_button_search.clicked.connect(self.search_ncbi)
             self.view.push_button_download_files.clicked.connect(self.download_files_wrapper)
             self.view.check_box_select_all_rows.clicked.connect(self.select_all_rows_in_table)
             self.view.radio_button_collections_genbank.toggled.connect(self.is_checked_GenBank_radio_button)
+            self.logger.debug("NCBI Window connections setup completed")
         except Exception as e:
             self.logger.error(f"Error setting up connections: {str(e)}", exc_info=True)
             show_error(self.settings, "Error setting up connections", str(e))
                     self.on_thread_completed()  # Increment completed threads for unavailable files
                     continue
+                downloader = self.model.DownloadThread(self, url, id, species_name, strain,
+                                                     self.view.check_box_file_types_fna.isChecked(),
+                                                     self.view.check_box_file_types_gbff.isChecked())
                 downloader.finished.connect(self.on_download_finished)
                 downloader.progress_updated.connect(self.update_progress)
                 downloader.status_updated.connect(self.update_status)
                 self.rename_files(self.model.files)
             elif not self.unavailable_files:
                 show_message(12, QtWidgets.QMessageBox.Icon.Warning, "No Files Downloaded", "No files were downloaded. Please check your selection and try again.")
     def show_unavailable_files_warning(self):
         warning_text = "The following files were not available for download:\n\n"
         for species_name, strain in self.unavailable_files:
     def on_rename_complete(self):
         try:
             self.view.set_download_files_status_label("Download and renaming complete.<br>Press Back to go back to the Main window.")
+            # Just trigger the database state update
+            self.settings.update_db_state()
+            # No need to manually refresh the Home tab as it will receive the db_state_updated signal
+            self.logger.info("Database state update triggered after NCBI download")
         except Exception as e:
             self.logger.error(f"Error in on_rename_complete: {str(e)}", exc_info=True)
             show_error(self.settings, "Error after renaming", str(e))
     def select_all_rows_in_table(self):
         if self.view.check_box_select_all_rows.isChecked():
             self.view.table_ncbi_results.selectAll()
             show_message("Warning!",
                          "The GenBank collection may contain poorly or partially annotated annotation files. "
                          "We highly recommend using the RefSeq collection if it is available.")

src/controllers/NewEndonucleaseController.py CHANGED Viewed

@@ -25,7 +25,6 @@ class NewEndonucleaseController:
             self.view.push_button_reset_form.clicked.connect(self._handle_reset_form)
             self.view.push_button_delete.clicked.connect(self._handle_delete)
             self.view.combo_box_select_endonuclease.currentIndexChanged.connect(self._handle_endonuclease_selection)
-            self.view.show()
         except Exception as e:
             show_error(self.settings, "Error setting up connections in NewEndonucleaseController", str(e))

             self.view.push_button_reset_form.clicked.connect(self._handle_reset_form)
             self.view.push_button_delete.clicked.connect(self._handle_delete)
             self.view.combo_box_select_endonuclease.currentIndexChanged.connect(self._handle_endonuclease_selection)
         except Exception as e:
             show_error(self.settings, "Error setting up connections in NewEndonucleaseController", str(e))

src/controllers/PopulatioAnalysisWindowController.py DELETED Viewed

File without changes

src/controllers/PopulationAnalysisWindowController.py CHANGED Viewed

@@ -2,58 +2,85 @@ from PyQt6 import QtWidgets
 from utils.ui import show_error, show_message, position_window
 from views.PopulationAnalysisWindowView import PopulationAnalysisWindowView
 from models.PopulationAnalysisWindowModel import PopulationAnalysisWindowModel
 class PopulationAnalysisWindowController:
     def __init__(self, global_settings):
         self.global_settings = global_settings
-        self.model = PopulationAnalysisWindowModel(global_settings)
-        self.view = PopulationAnalysisWindowView(global_settings)
         self.setup_connections()
     def setup_connections(self):
-        self.view.goBackButton.clicked.connect(self.go_back)
-        self.view.analyze_button.clicked.connect(self.pre_analyze)
-        self.view.clear_Button.clicked.connect(self.clear)
-        self.view.export_button.clicked.connect(self.export_tool)
-        self.view.find_locs_button.clicked.connect(self.find_locations)
-        self.view.clear_loc_button.clicked.connect(self.clear_loc_table)
-        self.view.query_seed_button.clicked.connect(self.custom_seed_search)
-        self.view.endoBox.currentIndexChanged.connect(self.change_endo)
-        self.view.table2.horizontalHeader().sectionClicked.connect(self.table2_sorting)
-        self.view.loc_finder_table.horizontalHeader().sectionClicked.connect(self.loc_table_sorter)
     def launch(self):
         try:
             self.get_data()
-            self.view.show()
         except Exception as e:
             show_error(self.global_settings, "Error in launch() in population analysis.", str(e))
     def get_data(self):
         try:
             self.fillEndo()
         except Exception as e:
             show_error(self.global_settings, "Error in get_data() in population analysis.", str(e))
     def fillEndo(self):
         try:
             endos = self.model.load_endonucleases()
             self.view.update_endo_dropdown(endos.keys())
             self.change_endo()
         except Exception as e:
             show_error(self.global_settings, "Error in fillEndo() in population analysis.", str(e))
     def change_endo(self):
         try:
             selected_endo = self.view.get_selected_endo()
             org_files = self.model.get_organism_files(selected_endo)
             self.view.update_org_table(org_files)
         except Exception as e:
-            show_error(self.global_settings, "Error in change_endo() in population analysis.", str(e))
     def pre_analyze(self):
         try:
-            selected_indexes = self.view.get_selected_organisms()
             if len(selected_indexes) == 0:
                 show_message(
                     fontSize=12,
@@ -73,37 +100,104 @@ class PopulationAnalysisWindowController:
     def fill_data(self):
         try:
-            self.view.show_loading_window(5)
             self.model.seeds = self.model.get_shared_seeds(self.model.db_files, True)
             if len(self.model.seeds) == 0:
-                self.view.hide_loading_window()
                 return
             seed_data = []
             for seed in self.model.seeds:
                 data = self.model.get_seed_data(seed, self.model.db_files)
-                seed_data.append(self.process_seed_data(seed, data))
-            self.view.update_shared_seeds_table(seed_data)
-            if len(self.model.db_files) > 1:
-                heatmap_data = self.model.get_heatmap_data(self.model.db_files)
-                self.view.plot_heatmap(heatmap_data, self.model.org_names)
-            self.view.hide_loading_window()
         except Exception as e:
             show_error(self.global_settings, "Error in fill_data() in population analysis.", str(e))
     def process_seed_data(self, seed, data):
-        # Process the seed data and return a list of values for the table
-        # This method should contain the logic to calculate percentages, averages, etc.
-        # Return a list that matches the columns in the shared seeds table
-        pass
     def custom_seed_search(self):
         try:
-            seeds = self.view.get_seed_input().split(',')
             seeds = [seed.strip().upper() for seed in seeds if seed.strip()]
             if not seeds:
@@ -124,7 +218,7 @@ class PopulationAnalysisWindowController:
                     )
                     return
-            self.view.update_shared_seeds_table(seed_data)
         except Exception as e:
             show_error(self.global_settings, "Error in custom_seed_search() in population analysis.", str(e))
@@ -140,6 +234,10 @@ class PopulationAnalysisWindowController:
                 )
                 return
             locations = self.model.get_seed_locations(selected_seeds, self.model.db_files)
             self.view.update_loc_finder_table(locations)
         except Exception as e:
@@ -151,11 +249,11 @@ class PopulationAnalysisWindowController:
         except Exception as e:
             show_error(self.global_settings, "Error in clear_loc_table() in population analysis.", str(e))
-    def table2_sorting(self, logicalIndex):
         try:
             self.view.sort_table2(logicalIndex)
         except Exception as e:
-            show_error(self.global_settings, "Error in table2_sorting() in population analysis.", str(e))
     def loc_table_sorter(self, logicalIndex):
         try:

 from utils.ui import show_error, show_message, position_window
 from views.PopulationAnalysisWindowView import PopulationAnalysisWindowView
 from models.PopulationAnalysisWindowModel import PopulationAnalysisWindowModel
+import logging
 class PopulationAnalysisWindowController:
     def __init__(self, global_settings):
         self.global_settings = global_settings
+        self.model = PopulationAnalysisWindowModel(self.global_settings)
+        self.view = PopulationAnalysisWindowView(self.global_settings)
+        self._init_ui()
         self.setup_connections()
     def setup_connections(self):
+        try:
+            # Group: Select Organisms
+            self.view.combo_box_endonuclease.currentIndexChanged.connect(self.change_endo)
+            self.view.push_button_analyze_organism.clicked.connect(self.pre_analyze)
+            # Group: Seed Analysis
+            self.view.push_button_query_seed.clicked.connect(self.custom_seed_search)
+            self.view.push_button_clear_seeds.clicked.connect(self.clear)
+            self.view.push_button_find_locations.clicked.connect(self.find_locations)
+            self.view.push_button_clear_locations.clicked.connect(self.clear_loc_table)
+            # Tables sorting
+            self.view.table_seed.horizontalHeader().sectionClicked.connect(self.seed_table_sorting)
+            self.view.table_locations.horizontalHeader().sectionClicked.connect(self.loc_table_sorter)
+        except Exception as e:
+            show_error(self.global_settings, "Error setting up connections in population analysis.", str(e))
+    def _init_ui(self):
+        self.launch()
     def launch(self):
         try:
+            self.logger = self.global_settings.get_logger()
+            self.logger.info("Launching Population Analysis Window")
             self.get_data()
         except Exception as e:
+            self.logger.error(f"Error in launch(): {str(e)}")
             show_error(self.global_settings, "Error in launch() in population analysis.", str(e))
     def get_data(self):
         try:
+            self.logger.info("Getting data for Population Analysis")
             self.fillEndo()
         except Exception as e:
+            self.logger.error(f"Error in get_data(): {str(e)}")
             show_error(self.global_settings, "Error in get_data() in population analysis.", str(e))
     def fillEndo(self):
         try:
+            self.logger.info("Starting fillEndo()")
             endos = self.model.load_endonucleases()
+            self.logger.debug(f"Loaded endonucleases: {endos}")
+            if not endos:
+                self.logger.warning("No endonucleases found")
+                show_error(self.global_settings, "Error", "No endonucleases found")
+                return
+            self.logger.info(f"Updating dropdown with {len(endos)} endonucleases")
             self.view.update_endo_dropdown(endos.keys())
             self.change_endo()
         except Exception as e:
+            self.logger.error(f"Error in fillEndo(): {str(e)}")
             show_error(self.global_settings, "Error in fillEndo() in population analysis.", str(e))
     def change_endo(self):
         try:
             selected_endo = self.view.get_selected_endo()
+            if not selected_endo:
+                return
             org_files = self.model.get_organism_files(selected_endo)
             self.view.update_org_table(org_files)
         except Exception as e:
+            show_error(self.settings, "Error in change_endo() in population analysis.", str(e))
     def pre_analyze(self):
         try:
+            selected_indexes = [index.row() for index in self.view.table_organism.selectionModel().selectedRows()]
             if len(selected_indexes) == 0:
                 show_message(
                     fontSize=12,
     def fill_data(self):
         try:
             self.model.seeds = self.model.get_shared_seeds(self.model.db_files, True)
             if len(self.model.seeds) == 0:
                 return
             seed_data = []
             for seed in self.model.seeds:
                 data = self.model.get_seed_data(seed, self.model.db_files)
+                processed_data = self.process_seed_data(seed, data)
+                if processed_data:  # Only add if data was processed successfully
+                    seed_data.append(processed_data)
+            if seed_data:  # Only update table if we have data
+                self.view.update_shared_seeds_table(seed_data)
+                if len(self.model.db_files) > 1:
+                    heatmap_data = self.model.get_heatmap_data(self.model.db_files)
+                    self.view.plot_heatmap(heatmap_data, self.model.org_names)
+            else:
+                self.logger.warning("No seed data was processed successfully")
         except Exception as e:
             show_error(self.global_settings, "Error in fill_data() in population analysis.", str(e))
     def process_seed_data(self, seed, data):
+        """Process seed data and return a tuple of values for the table"""
+        try:
+            # self.logger.debug(f"Processing seed data: {data}")
+            if not data or data['org_count'] == 0:
+                self.logger.warning(f"No data found for seed {seed}")
+                return None
+            # Calculate coverage percentage
+            coverage = (data['org_count'] / len(self.model.db_files)) * 100
+            coverage = float("%.2f" % coverage)
+            # Calculate average repeats per scaffold
+            avg_rep_per_scaff = data['total_count'] / data['org_count']
+            avg_rep_per_scaff = float("%.2f" % avg_rep_per_scaff)
+            # Handle missing data in threes/fives
+            threes = data['threes']
+            fives = data['fives']
+            if len(threes) < len(fives):
+                threes.extend([''] * (len(fives) - len(threes)))
+            elif len(fives) < len(threes):
+                fives.extend([''] * (len(threes) - len(fives)))
+            # Find majority sequence
+            majority_index = 0
+            if not threes or threes[0] == '':
+                majority = max(set(fives), key=fives.count)
+                majority_index = fives.index(majority)
+                consensus_seq = fives[majority_index] + seed
+                percent_consensus = (fives.count(fives[majority_index]) / len(fives)) * 100
+            elif not fives or fives[0] == '':
+                majority = max(set(threes), key=threes.count)
+                majority_index = threes.index(majority)
+                consensus_seq = seed + threes[majority_index]
+                percent_consensus = (threes.count(threes[majority_index]) / len(threes)) * 100
+            else:
+                # Both threes and fives present
+                combined = [f"{f}{t}" for f, t in zip(fives, threes)]
+                majority = max(set(combined), key=combined.count)
+                majority_index = combined.index(majority)
+                consensus_seq = fives[majority_index] + seed + threes[majority_index]
+                percent_consensus = (combined.count(majority) / len(combined)) * 100
+            percent_consensus = float("%.2f" % percent_consensus)
+            # Determine strand
+            strand = "+" if int(data['locs'][majority_index]) >= 0 else "-"
+            # Create the row data
+            row_data = (
+                seed,                   # Seed
+                coverage,              # % Coverage
+                data['total_count'],   # Total Repeats
+                avg_rep_per_scaff,     # Avg. Repeats/Scaffold
+                consensus_seq,         # Consensus Sequence
+                percent_consensus,     # % Consensus
+                data['scores'][majority_index],  # Score
+                data['pams'][majority_index],    # PAM
+                strand                 # Strand
+            )
+            self.logger.debug(f"Processed seed data: {row_data}")
+            return row_data
+        except Exception as e:
+            self.logger.error(f"Error processing seed data: {str(e)}")
+            show_error(self.global_settings, f"Error processing seed {seed}", str(e))
+            return None
     def custom_seed_search(self):
         try:
+            seeds = self.view.line_edit_seed.text().split(',')
             seeds = [seed.strip().upper() for seed in seeds if seed.strip()]
             if not seeds:
                     )
                     return
+            self.view.update_seed_table(seed_data)
         except Exception as e:
             show_error(self.global_settings, "Error in custom_seed_search() in population analysis.", str(e))
                 )
                 return
+            # Clear the locations table before adding new entries
+            self.view.table_locations.setRowCount(0)
+            # Get and display new locations
             locations = self.model.get_seed_locations(selected_seeds, self.model.db_files)
             self.view.update_loc_finder_table(locations)
         except Exception as e:
         except Exception as e:
             show_error(self.global_settings, "Error in clear_loc_table() in population analysis.", str(e))
+    def seed_table_sorting(self, logicalIndex):
         try:
             self.view.sort_table2(logicalIndex)
         except Exception as e:
+            show_error(self.global_settings, "Error in seed_table_sorting() in population analysis.", str(e))
     def loc_table_sorter(self, logicalIndex):
         try:

src/controllers/ViewTargetsController.py CHANGED Viewed

@@ -1,13 +1,21 @@
 from models.ViewTargetsModel import ViewTargetsModel
 from views.ViewTargetsView import ViewTargetsView
 from PyQt6.QtWidgets import QMessageBox
 from utils.ui import show_error
 class ViewTargetsController:
     def __init__(self, global_settings):
         self.global_settings = global_settings
         self.model = ViewTargetsModel(global_settings)
         self.view = ViewTargetsView(global_settings)
         self.setup_connections()
         self.organism = ""
         self.endonuclease = ""
@@ -26,28 +34,86 @@ class ViewTargetsController:
     def load_targets(self, selected_targets, organism, endonuclease):
         try:
             self.organism = organism
             self.endonuclease = endonuclease
             self.model.load_targets(selected_targets, organism, endonuclease)
             targets = self.model.get_targets()
             self.view.display_targets_in_table(targets)
             self.view.set_combo_box_endonuclease([endonuclease])
-            self.load_gene_viewer(selected_targets)
         except Exception as e:
             show_error(self.global_settings, "Error loading targets", str(e))
-    def load_gene_viewer(self, selected_targets):
         try:
-            genes = self.model.available_genes
-            self.view.set_combo_box_gene(genes)
             if genes:
-                self.display_gene_data(genes[0])
-            else:
-                self.view.set_text_edit_gene_viewer("No gene data available")
-                self.view.line_edit_start_location.clear()
-                self.view.line_edit_stop_location.clear()
         except Exception as e:
-            show_error(self.global_settings, "Error loading gene viewer", str(e))
     def perform_off_target_analysis(self):
         try:
@@ -77,13 +143,61 @@ class ViewTargetsController:
     def highlight_gene_viewer(self):
         try:
-            selected_targets = self.view.get_selected_targets()
-            if not selected_targets:
-                QMessageBox.warning(self.view, "No Selection", "Please select targets to highlight in the gene viewer.")
                 return
-            highlighted_sequence = self.model.highlight_targets_in_gene_viewer(selected_targets)
-            self.view.update_gene_viewer(highlighted_sequence)
         except Exception as e:
             show_error(self.global_settings, "Error highlighting gene viewer", str(e))
     def export_targets(self):

+import logging
 from models.ViewTargetsModel import ViewTargetsModel
 from views.ViewTargetsView import ViewTargetsView
 from PyQt6.QtWidgets import QMessageBox
 from utils.ui import show_error
+import time
+import traceback
+import threading
 class ViewTargetsController:
     def __init__(self, global_settings):
         self.global_settings = global_settings
+        start_time = time.time()
         self.model = ViewTargetsModel(global_settings)
         self.view = ViewTargetsView(global_settings)
+        init_time = time.time() - start_time
+        self.global_settings.logger.debug(f"ViewTargets initialization took: {init_time:.2f} seconds")
         self.setup_connections()
         self.organism = ""
         self.endonuclease = ""
     def load_targets(self, selected_targets, organism, endonuclease):
         try:
+            total_start = time.time()
             self.organism = organism
             self.endonuclease = endonuclease
+            # Time model loading
+            model_start = time.time()
             self.model.load_targets(selected_targets, organism, endonuclease)
+            model_time = time.time() - model_start
+            self.global_settings.logger.debug(f"Model load_targets took: {model_time:.2f} seconds")
+            # Time getting targets
+            targets_start = time.time()
             targets = self.model.get_targets()
+            targets_time = time.time() - targets_start
+            self.global_settings.logger.debug(f"Getting targets took: {targets_time:.2f} seconds")
+            # Time displaying targets
+            display_start = time.time()
             self.view.display_targets_in_table(targets)
+            display_time = time.time() - display_start
+            self.global_settings.logger.debug(f"Displaying targets took: {display_time:.2f} seconds")
+            # Time setting endonuclease
+            endo_start = time.time()
             self.view.set_combo_box_endonuclease([endonuclease])
+            endo_time = time.time() - endo_start
+            self.global_settings.logger.debug(f"Setting endonuclease took: {endo_time:.2f} seconds")
+            # Time loading gene viewer
+            gene_start = time.time()
+            self.load_gene_viewer()
+            gene_time = time.time() - gene_start
+            self.global_settings.logger.debug(f"Loading gene viewer took: {gene_time:.2f} seconds")
+            total_time = time.time() - total_start
+            self.global_settings.logger.debug(f"Total load_targets took: {total_time:.2f} seconds")
         except Exception as e:
             show_error(self.global_settings, "Error loading targets", str(e))
+    def load_gene_viewer(self):
         try:
+            start_time = time.time()
+            # Get available genes from the model
+            genes = self.model.get_available_genes()
             if genes:
+                # Update the gene combo box
+                self.view.combo_box_gene.clear()
+                self.view.combo_box_gene.addItems(genes)
+                # Fetch first gene immediately
+                first_gene = genes[0]
+                gene_data = self.model.get_gene_data(first_gene)
+                if gene_data:
+                    # Update the gene viewer with sequence
+                    self.view.set_text_edit_gene_viewer(gene_data['sequence'])
+                    # Update location fields if available
+                    if 'info' in gene_data and 'feature_location' in gene_data['info']:
+                        location = gene_data['info']['feature_location']
+                        if ':' in location:
+                            start, end = location.split(':')[0], location.split(':')[1].split('(')[0]
+                            self.view.line_edit_start_location.setText(start)
+                            self.view.line_edit_stop_location.setText(end)
+                    # Pre-fetch next few genes in background thread
+                    def prefetch_genes():
+                        for gene in genes[1:5]:  # Pre-fetch next 4 genes
+                            self.model.get_gene_data(gene)
+                    threading.Thread(target=prefetch_genes, daemon=True).start()
+            execution_time = time.time() - start_time
+            self.global_settings.logger.debug(f"Loading gene viewer took: {execution_time:.2f} seconds")
         except Exception as e:
+            self.global_settings.logger.error(f"Error in load_gene_viewer: {str(e)}\n{traceback.format_exc()}")
     def perform_off_target_analysis(self):
         try:
     def highlight_gene_viewer(self):
         try:
+            self.global_settings.logger.debug("Starting highlight_gene_viewer")
+            # Get selected targets
+            selected_rows = self.view.get_selected_targets()
+            self.global_settings.logger.debug(f"Selected targets: {selected_rows}")
+            if not selected_rows:
+                QMessageBox.warning(self.view, "No Selection",
+                                  "Please select targets to highlight in the gene viewer.")
                 return
+            # Convert table selections to the format expected by the model
+            targets_to_highlight = []
+            for target in selected_rows:
+                target_info = {
+                    'location': target['location'],
+                    'sequence': target['sequence'],
+                    'strand': target['strand']
+                }
+                targets_to_highlight.append(target_info)
+                self.global_settings.logger.debug(f"Target to highlight: {target_info}")
+            # Get current gene sequence
+            current_gene = self.view.combo_box_gene.currentText()
+            self.global_settings.logger.debug(f"Current gene: {current_gene}")
+            gene_data = self.model.get_gene_data(current_gene)
+            if not gene_data:
+                self.global_settings.logger.error("No gene data found")
+                QMessageBox.warning(self.view, "No Gene Data",
+                                  "Could not get gene data for highlighting.")
+                return
+            self.global_settings.logger.debug(f"Gene sequence length: {len(gene_data['sequence'])}")
+            # Highlight the sequences
+            if targets_to_highlight:
+                self.global_settings.logger.debug("Attempting to highlight sequences")
+                highlighted_sequence = self.model.highlight_targets_in_gene_viewer(targets_to_highlight)
+                if highlighted_sequence:
+                    self.global_settings.logger.debug("Successfully highlighted sequences")
+                    self.global_settings.logger.debug(f"Highlighted sequence length: {len(highlighted_sequence)}")
+                    self.view.update_gene_viewer(highlighted_sequence)
+                else:
+                    self.global_settings.logger.error("Failed to highlight sequences - returned None")
+                    QMessageBox.warning(self.view, "Highlighting Failed",
+                                      "Could not highlight the selected sequences. They may not be found in the current gene view.")
+            else:
+                self.global_settings.logger.error("No valid targets to highlight")
+                QMessageBox.warning(self.view, "No Valid Targets",
+                                  "Could not get sequence information from the selected rows.")
         except Exception as e:
+            self.global_settings.logger.error(f"Error in highlight_gene_viewer: {str(e)}\n{traceback.format_exc()}")
             show_error(self.global_settings, "Error highlighting gene viewer", str(e))
     def export_targets(self):

src/models/AnnotationParser.py CHANGED Viewed

@@ -2,6 +2,7 @@ from PyQt6.QtWidgets import QMessageBox
 from Bio import SeqIO
 import os
 import traceback
 class AnnotationParser:
     def __init__(self, global_settings):
@@ -9,25 +10,34 @@ class AnnotationParser:
         self.logger = global_settings.get_logger()
         self.annotation_file_name = ""
         self.available_genes = []
     def set_annotation_file(self, file_path):
-        self.annotation_file_name = file_path
-        self.logger.debug(f"Set annotation file to: {file_path}")
-        self._parse_available_genes()
-    def get_max_chrom(self):
-        try:
-            parser = SeqIO.parse(self.annotation_file_name, 'genbank')
-            max_chrom = sum(1 for _ in parser)
-            return max_chrom
-        except Exception as e:
-            self.logger.error(f"Error in get_max_chrom: {str(e)}")
-            self._show_error("Error in get_max_chrom", str(e))
-            return 0
-    def get_sequence_info(self, query):
-        # Implement this method if needed
-        pass
     def genbank_search(self, queries):
         try:
@@ -37,15 +47,34 @@ class AnnotationParser:
             self.logger.debug(f"Searching in annotation file: {self.annotation_file_name}")
             results_list = []
-            for record in SeqIO.parse(self.annotation_file_name, "genbank"):
                 for feature in record.features:
                     if feature.type in ['CDS', 'gene']:
-                        feature_info = self._get_feature_info(feature)
-                        for query in queries:
-                            if query.lower() in feature_info['feature_name'].lower() or \
-                               query.lower() in feature_info['feature_id'].lower() or \
-                               query.lower() in feature_info['feature_description'].lower():
-                                results_list.append((record.id, feature))
             self.logger.debug(f"Found {len(results_list)} results")
             return results_list
@@ -53,6 +82,20 @@ class AnnotationParser:
             self.logger.error(f"Error in genbank_search: {str(e)}")
             raise
     def find_which_file_version(self):
         try:
             if not self.annotation_file_name or os.path.basename(self.annotation_file_name) == "None":
@@ -110,25 +153,76 @@ class AnnotationParser:
     def get_available_genes(self):
         return self.available_genes
-    def get_gene_data(self, gene_name):
         try:
-            for record in SeqIO.parse(self.annotation_file_name, "genbank"):
-                for feature in record.features:
-                    if feature.type == 'gene' and self._get_feature_name(feature) == gene_name:
-                        self.logger.debug(f"Found gene {gene_name} in annotation file")
-                        self.logger.debug(f"Its sequence is {feature.extract(record.seq)}")
-                        self.logger.debug(f"Its feature is {feature}")
-                        self.logger.debug(f"Its feature info is {self._get_feature_info(feature)}")
-                        return {
-                            'sequence': str(feature.extract(record.seq)),
-                            'info': self._get_feature_info(feature)
                         }
-            self.logger.warning(f"Gene {gene_name} not found in annotation file")
             return None
         except Exception as e:
             self.logger.error(f"Error in get_gene_data: {str(e)}")
             return None
     def _parse_available_genes(self):
         self.available_genes = []
         try:

 from Bio import SeqIO
 import os
 import traceback
+from functools import lru_cache
 class AnnotationParser:
     def __init__(self, global_settings):
         self.logger = global_settings.get_logger()
         self.annotation_file_name = ""
         self.available_genes = []
+        self._feature_cache = {}  # Cache for feature data
+        self._record_cache = {}   # Cache for SeqIO records
+        self.gene_cache = {}  # Add cache for gene data
     def set_annotation_file(self, file_path):
+        if self.annotation_file_name != file_path:
+            self.annotation_file_name = file_path
+            self.logger.debug(f"Set annotation file to: {file_path}")
+            self._feature_cache.clear()  # Clear cache when file changes
+            self._record_cache.clear()
+            if hasattr(self, '_gene_index'):
+                delattr(self, '_gene_index')
+            # Pre-load records and build index
+            records = self._get_records()
+            self._build_gene_index(records)
+            self._parse_available_genes()
+    @lru_cache(maxsize=1)
+    def _get_records(self):
+        """Cache and return all records from the annotation file"""
+        if not self._record_cache:
+            try:
+                self._record_cache = list(SeqIO.parse(self.annotation_file_name, "genbank"))
+            except Exception as e:
+                self.logger.error(f"Error reading annotation file: {str(e)}")
+                return []
+        return self._record_cache
     def genbank_search(self, queries):
         try:
             self.logger.debug(f"Searching in annotation file: {self.annotation_file_name}")
             results_list = []
+            # Convert queries to lowercase set for faster lookup
+            queries = {q.lower() for q in queries}
+            # Use cached records
+            for record in self._get_records():
                 for feature in record.features:
                     if feature.type in ['CDS', 'gene']:
+                        # Create a hashable cache key using feature start and end positions
+                        cache_key = (record.id, feature.type,
+                                   str(feature.location.start),
+                                   str(feature.location.end))
+                        # Use cached feature info if available
+                        if cache_key not in self._feature_cache:
+                            self._feature_cache[cache_key] = self._get_feature_info(feature)
+                        feature_info = self._feature_cache[cache_key]
+                        # Combine searchable text for single comparison
+                        searchable_text = ' '.join([
+                            feature_info['feature_name'].lower(),
+                            feature_info['feature_id'].lower(),
+                            feature_info['feature_description'].lower()
+                        ])
+                        # Check if any query matches
+                        if any(query in searchable_text for query in queries):
+                            results_list.append((record.id, feature))
             self.logger.debug(f"Found {len(results_list)} results")
             return results_list
             self.logger.error(f"Error in genbank_search: {str(e)}")
             raise
+    def get_max_chrom(self):
+        try:
+            parser = SeqIO.parse(self.annotation_file_name, 'genbank')
+            max_chrom = sum(1 for _ in parser)
+            return max_chrom
+        except Exception as e:
+            self.logger.error(f"Error in get_max_chrom: {str(e)}")
+            self._show_error("Error in get_max_chrom", str(e))
+            return 0
+    def get_sequence_info(self, query):
+        # Implement this method if needed
+        pass
     def find_which_file_version(self):
         try:
             if not self.annotation_file_name or os.path.basename(self.annotation_file_name) == "None":
     def get_available_genes(self):
         return self.available_genes
+    def get_gene_data(self, gene_identifier):
+        """
+        Get gene data using gene name or locus tag with optimized caching
+        """
         try:
+            self.logger.debug(f"AnnotationParser.get_gene_data called with identifier: {gene_identifier}")
+            if not gene_identifier:
+                self.logger.warning("Empty gene identifier provided")
+                return None
+            # Handle numeric gene identifiers
+            if isinstance(gene_identifier, int) or str(gene_identifier).isdigit():
+                if self.available_genes:
+                    gene_identifier = self.available_genes[0]
+                else:
+                    return None
+            # Check main cache first
+            cache_key = f"gene_data_{gene_identifier}"
+            if cache_key in self._feature_cache:
+                return self._feature_cache[cache_key]
+            # Get cached records
+            records = self._get_records()
+            if not records:
+                return None
+            # Use gene index if available
+            if not hasattr(self, '_gene_index'):
+                self._build_gene_index(records)
+            # Try to get location from index
+            if gene_identifier in self._gene_index:
+                record_id, feature = self._gene_index[gene_identifier]
+                for record in records:
+                    if record.id == record_id:
+                        sequence = str(feature.extract(record.seq))
+                        feature_info = self._get_feature_info(feature)
+                        result = {
+                            'sequence': sequence,
+                            'info': feature_info
                         }
+                        self._feature_cache[cache_key] = result
+                        return result
             return None
         except Exception as e:
             self.logger.error(f"Error in get_gene_data: {str(e)}")
             return None
+    def _build_gene_index(self, records):
+        """Build an index of genes for faster lookup"""
+        self._gene_index = {}
+        try:
+            for record in records:
+                for feature in record.features:
+                    if feature.type == 'gene':
+                        gene_name = self._get_feature_name(feature)
+                        gene_id = self._get_feature_id(feature)
+                        if gene_name != "N/A":
+                            self._gene_index[gene_name] = (record.id, feature)
+                        if gene_id != "N/A":
+                            self._gene_index[gene_id] = (record.id, feature)
+        except Exception as e:
+            self.logger.error(f"Error building gene index: {str(e)}")
     def _parse_available_genes(self):
         self.available_genes = []
         try:

src/models/CSPRparser.py CHANGED Viewed

@@ -1,27 +1,129 @@
 from utils.sequence_utils import SeqTranslate
-import gzip
-##################################################################################################################################
-# Use: Use as a parser for the cspr files
-# Precondition: Only to the used with .cspr files. Will not work with any other files
-# This class also took some of the parsing functions from with classes (Multitargeting and Results) and stores them in here
-##################################################################################################################################
 class CSPRparser:
     def __init__(self, inputFileName, casper_info_path):
         self.fileName = inputFileName
         self.seqTrans = SeqTranslate(casper_info_path)
-    def read_targets(self, genename, pos_tuple, endo):
-        retList = []
-        with open(self.fileName, 'r') as f:
-            for line in f:
-                if line.startswith(f">{pos_tuple[0]}"):
-                    for line in f:
-                        if line.startswith('>'):
                             break
-                        line = line.strip().split(',')
-                        if pos_tuple[1] <= abs(int(line[0])) < pos_tuple[2]:
-                            strand = "-" if int(line[0]) < 0 else "+"
-                            retList.append((line[0], line[1], line[2], line[3], strand, endo))
-        return retList

 from utils.sequence_utils import SeqTranslate
+import logging
+from multiprocessing import Pool, cpu_count
+from functools import partial
 class CSPRparser:
     def __init__(self, inputFileName, casper_info_path):
         self.fileName = inputFileName
+        self.filename = inputFileName
         self.seqTrans = SeqTranslate(casper_info_path)
+        self.logger = logging.getLogger(__name__)
+        self._line_buffer = []  # Pre-allocate buffer for lines
+        self._cached_results = {}
+    def read_targets_batch(self, chromosome, targets, endonuclease):
+        """Ultra-fast target reading using direct tuple creation"""
+        try:
+            # Pre-process targets into a sorted list of ranges for faster lookup
+            target_ranges = []
+            for t in targets:
+                start = t['start']
+                end = t['end']
+                target_ranges.append((start, end, t['feature_name']))
+            target_ranges.sort()  # Sort by start position
+            # Pre-allocate results list
+            results = []
+            results_append = results.append
+            # Read file in binary mode for speed
+            with open(self.fileName, 'rb') as f:
+                # Skip header
+                for _ in range(3):
+                    f.readline()
+                # Find chromosome section
+                header = False
+                for line in f:
+                    if b'>' in line and str(chromosome).encode() in line:
+                        header = True
+                        break
+                # Read targets
+                if header:
+                    current_range_idx = 0
+                    max_ranges = len(target_ranges)
+                    while current_range_idx < max_ranges:
+                        line = f.readline()
+                        if not line or line.startswith(b'>'):
                             break
+                        if not line.strip():
+                            continue
+                        # Fast string splitting without decode
+                        parts = line.strip().split(b',')
+                        if not parts:
+                            continue
+                        try:
+                            pos = int(parts[0])
+                            abs_pos = abs(pos)
+                            # Get current target range
+                            start, end, feature_name = target_ranges[current_range_idx]
+                            # Skip if position is past current range
+                            if abs_pos >= end:
+                                current_range_idx += 1
+                                continue
+                            # Check if position is in range
+                            if start <= abs_pos < end:
+                                sequence = parts[1].decode()
+                                pam = sequence[-3:]
+                                target_seq = sequence[:-3]
+                                results_append({
+                                    'feature_name': feature_name,
+                                    'chromosome': chromosome,
+                                    'position': abs_pos,
+                                    'location': f"{abs_pos}-{abs_pos + 23}",
+                                    'sequence': target_seq,
+                                    'pam': pam,
+                                    'strand': "-" if pos < 0 else "+",
+                                    'score': float(parts[3]) if len(parts) > 3 else 0.0,
+                                    'endonuclease': endonuclease
+                                })
+                        except (ValueError, IndexError):
+                            continue
+            return results
+        except Exception as e:
+            self.logger.error(f"Error in read_targets_batch: {str(e)}")
+            return []
+    def parse_targets(self, file_path, region):
+        """Parse targets with parallel processing and caching"""
+        cache_key = f"{file_path}:{region}"
+        if cache_key in self._cached_results:
+            return self._cached_results[cache_key]
+        # Split the region into chunks for parallel processing
+        chunks = self._split_region(region)
+        with Pool() as pool:
+            results = pool.map(partial(self._parse_chunk, file_path), chunks)
+        # Combine results
+        combined_targets = []
+        for chunk_result in results:
+            combined_targets.extend(chunk_result)
+        self._cached_results[cache_key] = combined_targets
+        return combined_targets
+    def _split_region(self, region):
+        """Split a region into chunks for parallel processing"""
+        start, end = region
+        chunk_size = (end - start) // cpu_count()
+        chunks = []
+        for i in range(cpu_count()):
+            chunk_start = start + (i * chunk_size)
+            chunk_end = chunk_start + chunk_size if i < cpu_count()-1 else end
+            chunks.append((chunk_start, chunk_end))
+        return chunks

src/models/DatabaseManager.py CHANGED Viewed

@@ -1,5 +1,8 @@
 import os
 from PyQt6.QtCore import QObject, pyqtSignal, QFileSystemWatcher
 class DatabaseManager(QObject):
     db_state_updated = pyqtSignal(bool, str, list)  # Combined signal
@@ -115,9 +118,19 @@ class DatabaseManager(QObject):
     def _on_directory_changed(self, path):
         """Handle changes in the watched directory."""
         self.logger.debug(f"Detected change in directory: {path}")
-        cspr_files = self._get_cspr_files()
         is_valid, message = self.validate_db_path(path)
         self.db_state_updated.emit(is_valid, message, cspr_files)
     def _get_cspr_files(self):
         """Get a list of CSPR files in the current database directory."""
@@ -125,6 +138,15 @@ class DatabaseManager(QObject):
             return []
         return [f for f in os.listdir(self.db_path) if f.endswith('.cspr')]
     def check_db_state(self):
         """Check the current state of the database and emit signals if changed."""
         self.logger.debug("Checking database state")
@@ -135,8 +157,273 @@ class DatabaseManager(QObject):
         self.logger.debug(f"Database state: valid={is_valid}, message={message}")
         cspr_files = self._get_cspr_files()
-        self.logger.debug(f"Found {len(cspr_files)} CSPR files in the database")
-        message = f"Database is valid. Contains {len(cspr_files)} CSPR files."
         self.db_state_updated.emit(is_valid, message, cspr_files)

 import os
 from PyQt6.QtCore import QObject, pyqtSignal, QFileSystemWatcher
+import sqlite3
+from collections import Counter
+import statistics
 class DatabaseManager(QObject):
     db_state_updated = pyqtSignal(bool, str, list)  # Combined signal
     def _on_directory_changed(self, path):
         """Handle changes in the watched directory."""
         self.logger.debug(f"Detected change in directory: {path}")
+        # Get current state
         is_valid, message = self.validate_db_path(path)
+        # Get list of files
+        cspr_files = self._get_cspr_files()
+        gbff_files = self._get_gbff_files()  # Add method to get GBFF files
+        # Emit the signal with updated state
         self.db_state_updated.emit(is_valid, message, cspr_files)
+        # Log the change
+        self.logger.info(f"Database state updated - Valid: {is_valid}, Files: {len(cspr_files)} CSPR, {len(gbff_files)} GBFF")
     def _get_cspr_files(self):
         """Get a list of CSPR files in the current database directory."""
             return []
         return [f for f in os.listdir(self.db_path) if f.endswith('.cspr')]
+    def _get_gbff_files(self):
+        """Get a list of GBFF files in the database directory."""
+        if not self.db_path or not os.path.isdir(self.db_path):
+            return []
+        gbff_path = os.path.join(self.db_path, 'GBFF')
+        if not os.path.exists(gbff_path):
+            return []
+        return [f for f in os.listdir(gbff_path) if f.endswith('.gbff')]
     def check_db_state(self):
         """Check the current state of the database and emit signals if changed."""
         self.logger.debug("Checking database state")
         self.logger.debug(f"Database state: valid={is_valid}, message={message}")
         cspr_files = self._get_cspr_files()
+        gbff_files = self._get_gbff_files()
+        message = f"Database is valid. Contains {len(cspr_files)} CSPR files and {len(gbff_files)} GBFF files."
         self.db_state_updated.emit(is_valid, message, cspr_files)
+        self.logger.info(f"Database state checked - Valid: {is_valid}, Files: {len(cspr_files)} CSPR, {len(gbff_files)} GBFF")
+    def get_organisms_and_endos(self):
+        """Get mapping of organisms to their endonucleases and files"""
+        try:
+            if not self.db_path or not os.path.exists(self.db_path):
+                self.logger.error(f"Invalid database path: {self.db_path}")
+                return {}, {}
+            onlyfiles = [f for f in os.listdir(self.db_path) if os.path.isfile(os.path.join(self.db_path, f))]
+            cspr_files = [f for f in onlyfiles if f.endswith('.cspr')]
+            organisms_to_files = {}
+            organisms_to_endos = {}
+            for file in cspr_files:
+                try:
+                    # Parse filename
+                    newname = file[0:-5]  # Remove .cspr - changed from -4 to -5
+                    endo = newname[newname.rfind("_") + 1:]  # Get endonuclease name
+                    # Read organism name from first line of CSPR file
+                    file_path = os.path.join(self.db_path, file)
+                    with open(file_path, 'r') as hold:
+                        buf = hold.readline().strip()
+                        species = buf.replace("GENOME: ", "")
+                    # Store file mappings
+                    if species in organisms_to_files:
+                        organisms_to_files[species][endo] = [file, file.replace(".cspr", "_repeats.db")]
+                    else:
+                        organisms_to_files[species] = {}
+                        organisms_to_files[species][endo] = [file, file.replace(".cspr", "_repeats.db")]
+                    # Store endonuclease mappings
+                    if species in organisms_to_endos:
+                        if endo not in organisms_to_endos[species]:
+                            organisms_to_endos[species].append(endo)
+                    else:
+                        organisms_to_endos[species] = [endo]
+                except Exception as e:
+                    self.logger.error(f"Error processing file {file}: {str(e)}")
+                    continue
+            return organisms_to_files, organisms_to_endos
+        except Exception as e:
+            self.logger.error(f"Error getting organisms and endonucleases: {str(e)}")
+            return {}, {}
+    def get_repeats_data(self, db_file, row_limit=-1):
+        """Get repeats data for the seeds table"""
+        try:
+            conn = sqlite3.connect(db_file)
+            c = conn.cursor()
+            if row_limit == -1:
+                sql_query = "SELECT * FROM repeats ORDER BY count DESC;"
+            else:
+                sql_query = f"SELECT * FROM repeats ORDER BY count DESC LIMIT 0, {row_limit};"
+            repeats = c.execute(sql_query).fetchall()
+            processed_data = []
+            for repeat in repeats:
+                # Extract repeat info
+                seed = repeat[0]
+                chroms = repeat[1].split(",")
+                locs = repeat[2].split(",")
+                threes = repeat[3].split(",")
+                fives = repeat[4].split(",")
+                pams = repeat[5].split(",")
+                scores = repeat[6].split(",")
+                count = repeat[7]
+                # Handle missing data in threes/fives
+                if len(threes) < len(fives):
+                    threes.extend([''] * (len(fives) - len(threes)))
+                elif len(fives) < len(threes):
+                    fives.extend([''] * (len(threes) - len(fives)))
+                # Find majority sequence
+                majority_index = 0
+                three_prime, five_prime, both_prime = False, False, False
+                if threes[0] == '':
+                    majority = max(set(fives), key=fives.count)
+                    majority_index = fives.index(majority)
+                    five_prime = True
+                elif fives[0] == '':
+                    majority = max(set(threes), key=threes.count)
+                    majority_index = threes.index(majority)
+                    three_prime = True
+                else:
+                    # account for both 3 and 5 present
+                    threes_and_fives = []
+                    for i in range(len(threes)):
+                        threes_and_fives.append(threes[i] + fives[i])
+                    majority = max(set(threes_and_fives), key=threes_and_fives.count)
+                    majority_index = threes_and_fives.index(majority)
+                    both_prime = True
+                # Calculate average repeats per scaffold
+                location_repeat_counts = Counter(chroms)
+                avg_rep_per_scaff = sum(location_repeat_counts.values()) / len(location_repeat_counts.values())
+                avg_rep_per_scaff = float("%.2f" % avg_rep_per_scaff)
+                # Calculate consensus percentage
+                if five_prime:
+                    percent_consensus = (fives.count(fives[majority_index]) / len(fives)) * 100
+                elif three_prime:
+                    percent_consensus = (threes.count(threes[majority_index]) / len(threes)) * 100
+                elif both_prime:
+                    percent_consensus = (threes_and_fives.count(threes_and_fives[majority_index]) / len(threes_and_fives)) * 100
+                percent_consensus = float("%.2f" % percent_consensus)
+                # Determine strand
+                strand = "+" if int(locs[majority_index]) >= 0 else "-"
+                # Create processed row
+                processed_row = (
+                    seed,                                           # Seed
+                    count,                                         # Total Repeats
+                    avg_rep_per_scaff,                            # Avg. Repeats/Scaffold
+                    fives[majority_index] + seed + threes[majority_index],  # Consensus Sequence
+                    percent_consensus,                             # % Consensus
+                    scores[majority_index],                        # Score
+                    pams[majority_index],                         # PAM
+                    strand                                        # Strand
+                )
+                processed_data.append(processed_row)
+            conn.close()
+            return processed_data
+        except Exception as e:
+            self.logger.error(f"Error getting repeats data: {str(e)}")
+            raise
+    def get_seed_data(self, db_file, seed):
+        """Get detailed data for a specific seed"""
+        try:
+            conn = sqlite3.connect(db_file)
+            c = conn.cursor()
+            data = c.execute("""
+                SELECT chromosome, location, pam, score,
+                       five, three
+                FROM repeats
+                WHERE seed = ?
+            """, (seed,)).fetchall()
+            conn.close()
+            return data
+        except Exception as e:
+            self.logger.error(f"Error getting seed data: {str(e)}")
+            raise
+    def get_chro_bar_data(self, db_file, seed):
+        """Get chromosome distribution data for a seed"""
+        try:
+            conn = sqlite3.connect(db_file)
+            c = conn.cursor()
+            data = c.execute("SELECT chromosome FROM repeats WHERE seed = ?", (seed,)).fetchone()
+            conn.close()
+            if not data:
+                return Counter()
+            # Split the chromosome string and convert to integers
+            chromosomes = [int(x) for x in data[0].split(',')]
+            counts = Counter(chromosomes)
+            return counts
+        except Exception as e:
+            self.logger.error(f"Error getting chromosome bar data: {str(e)}")
+            raise
+    def get_seeds_vs_repeats_data(self, db_file):
+        """Get data for seeds vs repeats plot"""
+        try:
+            conn = sqlite3.connect(db_file)
+            c = conn.cursor()
+            # Count how many sequences have each repeat count
+            data = c.execute("""
+                SELECT count, COUNT(*) as num_sequences
+                FROM repeats
+                GROUP BY count
+                ORDER BY count ASC
+            """).fetchall()
+            conn.close()
+            if not data:
+                return None
+            # Separate into x and y values
+            x_vals = [row[0] for row in data]  # number of repeats
+            y_vals = [row[1] for row in data]  # number of sequences with that count
+            return {
+                'x_vals': x_vals,
+                'y_vals': y_vals
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting seeds vs repeats data: {str(e)}")
+            raise
+    def get_repeats_vs_seeds_data(self, db_file):
+        """Get data for repeats vs seeds plot"""
+        try:
+            self.logger.debug(f"Getting repeats vs seeds data from {db_file}")
+            conn = sqlite3.connect(db_file)
+            c = conn.cursor()
+            # Get all count values ordered by rowid to maintain order
+            self.logger.debug("Executing SQL query")
+            data = c.execute("SELECT count FROM repeats ORDER BY rowid;").fetchall()
+            self.logger.debug(f"Raw data from database: {data[:5]}...")  # Log first 5 entries
+            conn.close()
+            # Extract counts from tuples
+            counts = [row[0] for row in data]
+            self.logger.debug(f"Processed counts (first 5): {counts[:5]}...")
+            if not counts:
+                self.logger.warning("No count data found")
+                return None
+            # Calculate statistics
+            stats = {
+                'average': statistics.mean(counts),
+                'median': statistics.median(counts),
+                'mode': statistics.mode(counts),
+                'repeat_count': len(counts)
+            }
+            self.logger.debug(f"Calculated statistics: {stats}")
+            result = {
+                'counts': counts,
+                'stats': stats
+            }
+            self.logger.debug("Successfully prepared repeats vs seeds data")
+            return result
+        except Exception as e:
+            self.logger.error(f"Error getting repeats vs seeds data: {str(e)}")
+            raise
+    def calculate_statistics(self, db_file):
+        """Calculate global statistics"""
+        try:
+            conn = sqlite3.connect(db_file)
+            c = conn.cursor()
+            stats = {}
+            # Add your statistics calculations here
+            conn.close()
+            return stats
+        except Exception as e:
+            self.logger.error(f"Error calculating statistics: {str(e)}")
+            raise

src/models/FindTargetsModel.py CHANGED Viewed

@@ -2,72 +2,106 @@ from models.HomeWindowModel import HomeWindowModel
 from models.CSPRparser import CSPRparser
 from models.AnnotationParser import AnnotationParser
 import os
 class FindTargetsModel(HomeWindowModel):
     def __init__(self, global_settings):
         super().__init__(global_settings)
         self.results = {}
-        self.annotation_parser = AnnotationParser(global_settings)
     def find_targets(self, input_data):
         self.global_settings.logger.debug(f"Received input data: {input_data}")
-        print(f"Received input data: {input_data}")
         organism = input_data['organism']
         endo = input_data['endonuclease']
         org_files = self.get_organism_to_files()
-        if organism not in org_files:
-            error_msg = f"Organism '{organism}' not found in the database. Available organisms: {list(org_files.keys())}"
-            self.global_settings.logger.error(error_msg)
-            raise ValueError(error_msg)
-        if endo not in org_files[organism]:
-            error_msg = f"Endonuclease '{endo}' not found for organism '{organism}'. Available endonucleases: {list(org_files[organism].keys())}"
-            self.global_settings.logger.error(error_msg)
-            raise ValueError(error_msg)
         file_path = os.path.join(self.global_settings.get_db_path(), org_files[organism][endo][0])
-        parser = CSPRparser(file_path, self.global_settings.get_casper_info_path())
-        if input_data['search_type'] == 'feature':
-            self.results = self.find_targets_by_feature(parser, input_data)
-        elif input_data['search_type'] == 'position':
-            self.results = self.find_targets_by_position(parser, input_data)
-        elif input_data['search_type'] == 'sequence':
-            self.results = self.find_targets_by_sequence(parser, input_data)
-        else:
             error_msg = f"Invalid search type: {input_data['search_type']}"
             self.global_settings.logger.error(error_msg)
             raise ValueError(error_msg)
         return self.results
     def find_targets_by_feature(self, parser, input_data):
-        annotation_file = input_data['annotation_file']
         search_query = input_data['search_query'].strip().lower()
         annotation_file_path = os.path.join(self.global_settings.get_db_path(), 'GBFF', annotation_file)
-        self.annotation_parser.set_annotation_file(annotation_file_path)
         try:
-            results_list = self.annotation_parser.genbank_search([search_query])
             self.global_settings.logger.debug(f"Genbank search results: {results_list}")
         except Exception as e:
             self.global_settings.logger.error(f"Error in genbank_search: {str(e)}")
             return []
         formatted_results = []
         for chrom, feature in results_list:
             if feature.type in ['CDS']:
                 feature_info = self._get_feature_info(feature)
-                if (search_query == feature_info['feature_name'].lower() or
-                    search_query == feature_info['feature_id'].lower() or
-                    search_query in feature_info['feature_name'].lower() or
-                    search_query in feature_info['feature_id'].lower() or
-                    search_query in feature_info['feature_description'].lower()):
                     formatted_results.append({
                         'feature_type': feature.type,
                         'chromosome': chrom,

 from models.CSPRparser import CSPRparser
 from models.AnnotationParser import AnnotationParser
 import os
+from functools import lru_cache
 class FindTargetsModel(HomeWindowModel):
     def __init__(self, global_settings):
         super().__init__(global_settings)
         self.results = {}
+        self._parser_cache = {}  # Cache for CSPRparser instances
+        self.global_settings.annotation_file_changed.connect(self._on_annotation_file_changed)
+    def _on_annotation_file_changed(self, new_annotation_file):
+        """Clear caches when annotation file changes"""
+        self.global_settings.logger.debug(f"FindTargetsModel clearing caches for new annotation file: {new_annotation_file}")
+        self._parser_cache.clear()
+    @lru_cache(maxsize=32)
+    def _get_parser(self, file_path):
+        """Cache CSPRparser instances for reuse"""
+        if file_path not in self._parser_cache:
+            self._parser_cache[file_path] = CSPRparser(file_path, self.global_settings.get_casper_info_path())
+        return self._parser_cache[file_path]
     def find_targets(self, input_data):
         self.global_settings.logger.debug(f"Received input data: {input_data}")
         organism = input_data['organism']
         endo = input_data['endonuclease']
         org_files = self.get_organism_to_files()
+        # Validate input data
+        self._validate_input(organism, endo, org_files)
+        # Get file path and parser
         file_path = os.path.join(self.global_settings.get_db_path(), org_files[organism][endo][0])
+        parser = self._get_parser(file_path)
+        # Use dictionary for faster lookup
+        search_types = {
+            'feature': self.find_targets_by_feature,
+            'position': self.find_targets_by_position,
+            'sequence': self.find_targets_by_sequence
+        }
+        search_func = search_types.get(input_data['search_type'])
+        if not search_func:
             error_msg = f"Invalid search type: {input_data['search_type']}"
             self.global_settings.logger.error(error_msg)
             raise ValueError(error_msg)
+        self.results = search_func(parser, input_data)
         return self.results
+    def _validate_input(self, organism, endo, org_files):
+        """Validate input parameters"""
+        if organism not in org_files:
+            error_msg = f"Organism '{organism}' not found in the database. Available organisms: {list(org_files.keys())}"
+            self.global_settings.logger.error(error_msg)
+            raise ValueError(error_msg)
+        if endo not in org_files[organism]:
+            error_msg = f"Endonuclease '{endo}' not found for organism '{organism}'. Available endonucleases: {list(org_files[organism].keys())}"
+            self.global_settings.logger.error(error_msg)
+            raise ValueError(error_msg)
     def find_targets_by_feature(self, parser, input_data):
+        # Get annotation file from input data or global settings
+        annotation_file = (input_data.get('annotation_file') or
+                         self.global_settings.get_current_annotation_file())
         search_query = input_data['search_query'].strip().lower()
+        # Create new annotation parser instance for each search
+        annotation_parser = AnnotationParser(self.global_settings)
         annotation_file_path = os.path.join(self.global_settings.get_db_path(), 'GBFF', annotation_file)
+        annotation_parser.set_annotation_file(annotation_file_path)
         try:
+            results_list = annotation_parser.genbank_search([search_query])
             self.global_settings.logger.debug(f"Genbank search results: {results_list}")
         except Exception as e:
             self.global_settings.logger.error(f"Error in genbank_search: {str(e)}")
             return []
+        # Use a set for faster lookups
+        search_terms = {search_query}
         formatted_results = []
+        # Pre-calculate feature info once for each feature
         for chrom, feature in results_list:
             if feature.type in ['CDS']:
                 feature_info = self._get_feature_info(feature)
+                # Combine all searchable text into one string for a single search operation
+                searchable_text = ' '.join([
+                    feature_info['feature_name'].lower(),
+                    feature_info['feature_id'].lower(),
+                    feature_info['feature_description'].lower()
+                ])
+                # Single check if any search term is in the searchable text
+                if any(term in searchable_text for term in search_terms):
                     formatted_results.append({
                         'feature_type': feature.type,
                         'chromosome': chrom,

src/models/GlobalSettings.py CHANGED Viewed

@@ -15,6 +15,7 @@ class GlobalSettings(QObject):
     db_state_updated = pyqtSignal(bool, str, list)  # Combined signal
     first_time_startup = pyqtSignal()  # New signal
     endonuclease_updated = pyqtSignal()
     def __init__(self, app_dir_path):
         super().__init__()
@@ -45,6 +46,8 @@ class GlobalSettings(QObject):
         self.main_window = None
     def _initialize_directories(self):
         self.src_dir_path = os.path.join(self.app_dir_path, 'src')
         self.ui_dir_path = os.path.join(self.src_dir_path, self.config_manager.get_config_value('paths.ui'))
@@ -268,5 +271,19 @@ class GlobalSettings(QObject):
     def get_endonucleases(self):
         return self.config_manager.get_endonucleases()
 # Global instance
 global_settings = None

     db_state_updated = pyqtSignal(bool, str, list)  # Combined signal
     first_time_startup = pyqtSignal()  # New signal
     endonuclease_updated = pyqtSignal()
+    annotation_file_changed = pyqtSignal(str)  # New signal for annotation file changes
     def __init__(self, app_dir_path):
         super().__init__()
         self.main_window = None
+        self._current_annotation_file = None
     def _initialize_directories(self):
         self.src_dir_path = os.path.join(self.app_dir_path, 'src')
         self.ui_dir_path = os.path.join(self.src_dir_path, self.config_manager.get_config_value('paths.ui'))
     def get_endonucleases(self):
         return self.config_manager.get_endonucleases()
+    def set_current_annotation_file(self, annotation_file):
+        """Set the current annotation file and notify listeners"""
+        if self._current_annotation_file != annotation_file:
+            self._current_annotation_file = annotation_file
+            self.logger.debug(f"Current annotation file changed to: {annotation_file}")
+            self.annotation_file_changed.emit(annotation_file)
+    def get_current_annotation_file(self):
+        """Get the currently selected annotation file"""
+        if not self._current_annotation_file and hasattr(self, '_current_home_window'):
+            # Try to get from home window if not set
+            self._current_annotation_file = self._current_home_window.get_annotation_file()
+        return self._current_annotation_file
 # Global instance
 global_settings = None

src/models/MultitargetingWindowModel.py CHANGED Viewed

@@ -1,140 +1,132 @@
 import os
-import sqlite3
-from collections import Counter
-import statistics
-import models.GlobalSettings as GlobalSettings
-from models.CSPRparser import CSPRparser
 class MultitargetingWindowModel:
     def __init__(self, global_settings):
-        self.global_settings = global_settings
         self.cspr_file = ""
         self.db_file = ""
-        self.organisms_to_files = {}
-        self.organisms_to_endos = {}
-        self.chromo_length = []
-        self.max_repeats = 1
-        self.average = 0
-        self.median = 0
-        self.mode = 0
-        self.average_unique = 0
-        self.average_rep = 0
-        self.repeat_count = 0
         self.row_limit = 1000
-        self.parser = CSPRparser("", self.global_settings.get_casper_info_path())
-        self.load_organisms_and_endos()
-    def load_organisms_and_endos(self):
-        # This method should populate the organisms_to_endos dictionary
-        # You'll need to implement the logic to load this data from your database or files
-        # For example:
-        # self.organisms_to_endos = {
-        #     "E. coli": ["Cas9", "Cas12a"],
-        #     "S. cerevisiae": ["Cas9"],
-        #     # ... other organisms and their associated endonucleases
-        # }
-        pass
     def get_organisms(self):
-        # Return the list of organisms
         return list(self.organisms_to_endos.keys())
     def get_endos_for_organism(self, organism):
-        # Return the list of endonucleases for a given organism
         return self.organisms_to_endos.get(organism, [])
     def set_files(self, organism, endo):
-        self.cspr_file = self.organisms_to_files[organism][endo][0]
-        self.db_file = self.organisms_to_files[organism][endo][1]
-    def get_kstats(self):
-        kstats = []
-        with open(self.cspr_file, "r") as f:
-            for line in f:
-                if "KARYSTATS" in line:
-                    kstats = line.replace("KARYSTATS: ", "").strip().split(',')[:-1]
-                    break
-        return kstats
     def get_repeats_data(self):
-        conn = sqlite3.connect(self.db_file)
-        c = conn.cursor()
-        if self.row_limit == -1:
-            sql_query = "SELECT * FROM repeats ORDER BY count DESC;"
-        else:
-            sql_query = f"SELECT * FROM repeats ORDER BY count DESC LIMIT 0, {self.row_limit};"
-        data = c.execute(sql_query).fetchall()
-        c.close()
-        conn.close()
-        return data
     def get_seed_data(self, seed):
-        conn = sqlite3.connect(self.db_file)
-        c = conn.cursor()
-        data = c.execute("SELECT chromosome, location, pam, score, five, three FROM repeats WHERE seed = ?", (seed,)).fetchone()
-        c.close()
-        conn.close()
-        return data
-    def process_seed_data(self, seed_data, kstats):
-        chromo, pos, pam, score, five, three = seed_data
-        chromo = chromo.split(',')
-        pos = pos.split(',')
-        pam = pam.split(',')
-        score = score.split(',')
-        five = five.split(',')
-        three = three.split(',')
-        seed_data = {}
-        event_data = {}
-        for i in range(len(chromo)):
-            curr_chromo = int(chromo[i])
-            dir = "+" if int(pos[i]) >= 0 else "-"
-            normalized_location = abs(float(pos[i]) / float(kstats[curr_chromo - 1]))
-            if curr_chromo in seed_data:
-                seed_data[curr_chromo].append(normalized_location)
-                event_data[curr_chromo].append([normalized_location, pos[i], five[i] + seed + three[i], pam[i], score[i], dir])
-            else:
-                seed_data[curr_chromo] = [normalized_location]
-                event_data[curr_chromo] = [[normalized_location, pos[i], five[i] + seed + three[i], pam[i], score[i], dir]]
-        return seed_data, event_data
     def get_chro_bar_data(self, seed):
-        conn = sqlite3.connect(self.db_file)
-        c = conn.cursor()
-        data = c.execute("SELECT chromosome FROM repeats WHERE seed = ?", (seed,)).fetchone()
-        c.close()
-        conn.close()
-        data = [int(x) for x in data[0].split(',')]
-        bar_data = Counter(data)
-        return bar_data
     def get_seeds_vs_repeats_data(self):
-        conn = sqlite3.connect(self.db_file)
-        c = conn.cursor()
-        data = c.execute("select count, COUNT(count) as cnt from repeats group by count order by cnt DESC;").fetchall()
-        c.close()
-        conn.close()
-        return data
     def get_repeats_vs_seeds_data(self):
-        conn = sqlite3.connect(self.db_file)
-        c = conn.cursor()
-        data = c.execute("SELECT count from repeats;").fetchall()
-        c.close()
-        conn.close()
-        y1 = [row[0] for row in data]
-        self.average = statistics.mean(y1)
-        self.mode = statistics.mode(y1)
-        self.median = statistics.median(y1)
-        self.repeat_count = len(y1)
-        return y1
-    def set_row_limit(self, limit):
-        self.row_limit = limit

 import os
 class MultitargetingWindowModel:
     def __init__(self, global_settings):
+        self.settings = global_settings
+        self.logger = global_settings.get_logger()
         self.cspr_file = ""
         self.db_file = ""
         self.row_limit = 1000
+        # Get organism and endo mappings from DatabaseManager
+        self.organisms_to_files, self.organisms_to_endos = self.settings.db_manager.get_organisms_and_endos()
     def get_organisms(self):
+        """Get list of available organisms"""
         return list(self.organisms_to_endos.keys())
     def get_endos_for_organism(self, organism):
+        """Get available endonucleases for given organism"""
         return self.organisms_to_endos.get(organism, [])
     def set_files(self, organism, endo):
+        """Set the CSPR and DB files for analysis"""
+        if not organism or not endo:
+            self.logger.error("Organism or endonuclease not specified")
+            raise ValueError("Organism and endonuclease must be specified")
+        self.cspr_file = self._get_cspr_file_path(organism, endo)
+        self.db_file = self._get_db_file_path(organism, endo)
+        if not self.cspr_file or not self.db_file:
+            raise FileNotFoundError("Required files not found")
     def get_repeats_data(self):
+        """Get repeats data for the seeds table"""
+        if not self.db_file:
+            raise ValueError("Database file not set. Please select an organism and endonuclease first.")
+        return self.settings.db_manager.get_repeats_data(self.db_file, self.row_limit)
     def get_seed_data(self, seed):
+        """Get detailed data for a specific seed"""
+        return self.settings.db_manager.get_seed_data(self.db_file, seed)
     def get_chro_bar_data(self, seed):
+        """Get chromosome distribution data for a seed"""
+        return self.settings.db_manager.get_chro_bar_data(self.db_file, seed)
     def get_seeds_vs_repeats_data(self):
+        """Get data for seeds vs repeats plot"""
+        return self.settings.db_manager.get_seeds_vs_repeats_data(self.db_file)
     def get_repeats_vs_seeds_data(self):
+        """Get data for repeats vs seeds plot"""
+        return self.settings.db_manager.get_repeats_vs_seeds_data(self.db_file)
+    def calculate_statistics(self):
+        """Calculate global statistics"""
+        return self.settings.db_manager.calculate_statistics(self.db_file)
+    def get_sql_settings(self):
+        """Get current SQL query settings"""
+        return {
+            'row_limit': self.row_limit
+        }
+    def update_sql_settings(self, settings):
+        """Update SQL query settings"""
+        if 'row_limit' in settings:
+            self.row_limit = settings['row_limit']
+    # Keep the file path methods as they are specific to this model
+    def _get_cspr_file_path(self, organism, endo):
+        """Get path to CSPR file for organism/endo combination"""
+        try:
+            if organism not in self.organisms_to_files or endo not in self.organisms_to_files[organism]:
+                self.logger.error(f"No CSPR file mapping found for {organism} with {endo}")
+                return None
+            file_name = self.organisms_to_files[organism][endo][0]
+            cspr_path = os.path.join(self.settings.get_db_path(), file_name)
+            if not os.path.exists(cspr_path):
+                self.logger.error(f"CSPR file not found: {cspr_path}")
+                return None
+            return cspr_path
+        except Exception as e:
+            self.logger.error(f"Error getting CSPR file path: {str(e)}")
+            return None
+    def _get_db_file_path(self, organism, endo):
+        """Get path to DB file for organism/endo combination"""
+        try:
+            if organism not in self.organisms_to_files or endo not in self.organisms_to_files[organism]:
+                self.logger.error(f"No DB file mapping found for {organism} with {endo}")
+                return None
+            file_name = self.organisms_to_files[organism][endo][1]
+            db_path = os.path.join(self.settings.get_db_path(), file_name)
+            if not os.path.exists(db_path):
+                self.logger.error(f"Database file not found: {db_path}")
+                return None
+            return db_path
+        except Exception as e:
+            self.logger.error(f"Error getting database file path: {str(e)}")
+            return None
+    def get_kstats(self):
+        """Get kstats from CSPR file"""
+        try:
+            if not self.cspr_file:
+                self.logger.error("CSPR file not set")
+                raise ValueError("CSPR file not set. Please select an organism and endonuclease first.")
+            kstats = []
+            with open(self.cspr_file, "r") as f:
+                for line in f:
+                    if "KARYSTATS" in line:
+                        kstats = line.replace("KARYSTATS: ", "").strip().split(',')[:-1]
+                        break
+            if not kstats:
+                raise ValueError("No KARYSTATS found in CSPR file")
+            return kstats
+        except Exception as e:
+            self.logger.error(f"Error getting kstats: {str(e)}")
+            raise

src/models/NCBIWindowModel.py CHANGED Viewed

@@ -10,6 +10,8 @@ import platform
 import warnings
 import xml.etree.ElementTree as ET
 from PyQt6.QtCore import Qt
 class NCBIWindowModel:
     def __init__(self, settings):
@@ -20,6 +22,9 @@ class NCBIWindowModel:
         self.refseq_ftp_dict = {}
         self.files = []  # Initialize the files list
         Entrez.email = "your_email@example.com"  # Replace with a valid email
         # Suppress the XMLParsedAsHTMLWarning
         warnings.filterwarnings("ignore", category=XMLParsedAsHTMLWarning)
@@ -230,3 +235,118 @@ class CustomProxyModel(QtCore.QSortFilterProxyModel):
             if regex.match(text).hasMatch():
                 return False
         return True

 import warnings
 import xml.etree.ElementTree as ET
 from PyQt6.QtCore import Qt
+import socket
+from urllib.parse import urlparse
 class NCBIWindowModel:
     def __init__(self, settings):
         self.refseq_ftp_dict = {}
         self.files = []  # Initialize the files list
         Entrez.email = "your_email@example.com"  # Replace with a valid email
+        # Make DownloadThread accessible through the model
+        self.DownloadThread = DownloadThread
         # Suppress the XMLParsedAsHTMLWarning
         warnings.filterwarnings("ignore", category=XMLParsedAsHTMLWarning)
             if regex.match(text).hasMatch():
                 return False
         return True
+class DownloadThread(QtCore.QThread):
+    finished = QtCore.pyqtSignal(bool)
+    progress_updated = QtCore.pyqtSignal(int, int, int)
+    status_updated = QtCore.pyqtSignal(str)
+    all_completed = QtCore.pyqtSignal()
+    def __init__(self, controller, url, id, species_name, strain, download_fna, download_gbff):
+        super().__init__()
+        self.controller = controller
+        self.url = url
+        self.id = id
+        self.species_name = species_name
+        self.strain = strain
+        self.download_fna = download_fna
+        self.download_gbff = download_gbff
+    def run(self):
+        try:
+            parsed_url = urlparse(self.url)
+            ftp_host = parsed_url.netloc
+            ftp_path = parsed_url.path
+            self.controller.logger.info(f"Attempting to connect to FTP server: {ftp_host}")
+            try:
+                ip_address = socket.gethostbyname(ftp_host)
+                self.controller.logger.info(f"Resolved IP address: {ip_address}")
+            except socket.gaierror as e:
+                self.controller.logger.error(f"Failed to resolve hostname: {ftp_host}. Error: {str(e)}")
+                self.finished.emit(False)
+                return
+            ftp = FTP(ftp_host)
+            ftp.login()
+            ftp.cwd(ftp_path)
+            ftp.set_pasv(True)
+            # Set binary mode before any operations
+            ftp.voidcmd('TYPE I')
+            files_to_download = []
+            # Get list of all files
+            all_files = ftp.nlst()
+            # Process FNA files if requested
+            if self.download_fna:
+                # Find the main genomic FNA file (should be exactly one)
+                genomic_fna = [f for f in all_files
+                             if f.endswith('_genomic.fna.gz')
+                             and not any(x in f for x in ['cds_from', 'rna_from'])]
+                if genomic_fna:
+                    files_to_download.append(genomic_fna[0])
+                    self.controller.logger.info(f"Found main genomic FNA file: {genomic_fna[0]}")
+            # Process GBFF files if requested
+            if self.download_gbff:
+                gbff_files = [f for f in all_files if f.endswith('_genomic.gbff.gz')]
+                files_to_download.extend(gbff_files)
+                self.controller.logger.info(f"Found GBFF files: {gbff_files}")
+            # Calculate total size with error handling
+            total_size = 0
+            for file in files_to_download:
+                try:
+                    size = ftp.size(file)
+                    if size is not None:
+                        total_size += size
+                except Exception as e:
+                    self.controller.logger.warning(f"Could not get size for file {file}: {str(e)}")
+            downloaded_size = 0
+            # Download files
+            for file in files_to_download:
+                try:
+                    self.status_updated.emit(f"Downloading: {file}")
+                    file_type = 'FNA' if file.endswith('.fna.gz') else 'GBFF'
+                    output_dir = os.path.join(self.controller.settings.CSPR_DB, file_type)
+                    os.makedirs(output_dir, exist_ok=True)
+                    local_filename = os.path.join(output_dir, file)
+                    self.controller.logger.info(f"Downloading file: {file} to {local_filename}")
+                    with open(local_filename, 'wb') as local_file:
+                        def callback(data):
+                            local_file.write(data)
+                            nonlocal downloaded_size
+                            downloaded_size += len(data)
+                            if total_size > 0:
+                                self.progress_updated.emit(self.id, downloaded_size, total_size)
+                        ftp.retrbinary(f"RETR {file}", callback)
+                    self.controller.logger.info(f"Download complete: {file}")
+                    self.status_updated.emit(f"Decompressing: {file}")
+                    self.controller.model.decompress_file(local_filename)
+                    decompressed_filename = local_filename[:-3]
+                    self.controller.model.add_downloaded_file(decompressed_filename)
+                except Exception as e:
+                    self.controller.logger.error(f"Error downloading file {file}: {str(e)}")
+                    continue
+            ftp.quit()
+            self.controller.logger.info(f"All files downloaded and decompressed successfully for ID: {self.id}")
+            self.all_completed.emit()
+            self.finished.emit(True)
+        except Exception as e:
+            self.controller.logger.error(f"Download error for ID {self.id}: {str(e)}", exc_info=True)
+            self.finished.emit(False)

src/models/NewGenomeWindowModel.py CHANGED Viewed

@@ -88,9 +88,9 @@ class NewGenomeWindowModel(QObject):
             f'{db_path}',
             f'{self.settings.get_casper_info_path()}',
             f'{file_path}',
-            f'{organism_name} {strain}',
             'notes',
-            f'"DATA:{endonuclease_data["endonuclease_on_target_scoring"]}"'
         ]
         return arguments

             f'{db_path}',
             f'{self.settings.get_casper_info_path()}',
             f'{file_path}',
+            f'"{organism_name} {strain}"',
             'notes',
+            f'DATA:{endonuclease_data["endonuclease_on_target_scoring"]}'
         ]
         return arguments

src/models/PopulationAnalysisWindowModel.py CHANGED Viewed

@@ -5,8 +5,9 @@ from utils.ui import show_error
 class PopulationAnalysisWindowModel:
     def __init__(self, global_settings):
-        self.global_settings = global_settings
-        self.app_dir = global_settings.get_app_dir()
         self.cspr_files = []
         self.db_files = []
         self.org_names = {}
@@ -16,37 +17,75 @@ class PopulationAnalysisWindowModel:
         self.index_to_db = {}
     def load_endonucleases(self):
-        endos = {}
         try:
-            with open(self.global_settings.get_casper_info_path(), 'r') as f:
-                for line in f:
-                    if line.startswith('ENDONUCLEASES'):
-                        for line in f:
-                            if line.startswith('-'):
-                                break
-                            line_tokens = line.strip().split(';')
-                            endo = line_tokens[0]
-                            pam = line_tokens[1].split(',')[0] if ',' in line_tokens[1] else line_tokens[1]
-                            default_five_length = line_tokens[2]
-                            default_seed_length = line_tokens[3]
-                            default_three_length = line_tokens[4]
-                            endos[f"{endo} PAM: {pam}"] = (endo, pam, default_five_length, default_seed_length, default_three_length)
         except Exception as e:
-            show_error(self.global_settings, "Error loading endonucleases", str(e))
-        return endos
-    def get_organism_files(self, endo):
         org_files = []
         try:
-            for file in os.listdir(self.global_settings.CSPR_DB):
-                if file.endswith('.cspr') and file[file.rfind('_') + 1:file.find('.cspr')] == endo:
-                    cspr_file = os.path.join(self.global_settings.CSPR_DB, file)
-                    db_file = cspr_file.replace(".cspr", "_repeats.db")
-                    with open(cspr_file, 'r') as f:
-                        org_name = f.readline().split(":")[-1].strip()
-                    org_files.append((org_name, cspr_file, db_file))
         except Exception as e:
-            show_error(self.global_settings, "Error getting organism files", str(e))
         return org_files
     def get_shared_seeds(self, db_files, limit=False):
@@ -131,6 +170,11 @@ class PopulationAnalysisWindowModel:
         locations = []
         try:
             for db_file in db_files:
                 with sqlite3.connect(db_file) as conn:
                     c = conn.cursor()
                     for seed in seeds:
@@ -145,15 +189,25 @@ class PopulationAnalysisWindowModel:
                                 locations.append({
                                     'seed': seed,
                                     'sequence': sequence,
-                                    'organism': os.path.basename(db_file).split('_')[0],
                                     'chromosome': chrom,
                                     'location': abs(int(locs[i]))
                                 })
         except Exception as e:
             show_error(self.global_settings, "Error getting seed locations", str(e))
         return locations
     def get_org_names(self):
-        # Implement this method to populate self.org_names
-        pass

 class PopulationAnalysisWindowModel:
     def __init__(self, global_settings):
+        self.settings = global_settings
+        self.logger = self.settings.get_logger()
+        self.app_dir = self.settings.get_app_dir_path()
         self.cspr_files = []
         self.db_files = []
         self.org_names = {}
         self.index_to_db = {}
     def load_endonucleases(self):
+        """Load endonucleases from GlobalSettings"""
         try:
+            self.logger.info("Starting load_endonucleases()")
+            # Get endonucleases from global settings
+            endos = self.settings.get_endonucleases()
+            self.logger.debug(f"Raw endonucleases from settings: {endos}")
+            if not endos:
+                self.logger.warning("No endonucleases returned from settings")
+                return {}
+            # Format the endonucleases for display
+            formatted_endos = {}
+            for endo, data in endos.items():
+                self.logger.debug(f"Processing endo: {endo}, data: {data}")
+                pam = data.get('pam', '').strip()
+                # Remove any extra "PAM:" text that might be in the PAM string
+                pam = pam.replace('PAM:', '').strip()
+                # Create display name without duplicate "PAM:" text
+                display_name = f"{endo}"
+                formatted_endos[display_name] = (endo, pam,
+                                              data.get('default_five_length', ''),
+                                              data.get('default_seed_length', ''),
+                                              data.get('default_three_length', ''))
+            self.logger.info(f"Successfully formatted {len(formatted_endos)} endonucleases")
+            self.logger.debug(f"Formatted endonucleases: {formatted_endos}")
+            return formatted_endos
         except Exception as e:
+            self.logger.error(f"Error loading endonucleases: {str(e)}")
+            self.logger.exception("Full traceback:")
+            show_error(self.settings, "Error loading endonucleases", str(e))
+            return {}
+    def get_organism_files(self, endo_display_name):
+        """Get organism files for selected endonuclease using DatabaseManager"""
         org_files = []
         try:
+            # Extract just the endonuclease name from the display text (remove PAM)
+            endo = endo_display_name.split(" - PAM:")[0].strip()
+            self.logger.info(f"Getting organism files for endonuclease: {endo}")
+            # Get organism mappings from database manager
+            organisms_to_files, organisms_to_endos = self.settings.db_manager.get_organisms_and_endos()
+            # Process each organism that has this endonuclease
+            for organism, endos in organisms_to_endos.items():
+                if endo in endos:
+                    cspr_file = os.path.join(self.settings.CSPR_DB, organisms_to_files[organism][endo][0])
+                    db_file = os.path.join(self.settings.CSPR_DB, organisms_to_files[organism][endo][1])
+                    if not os.path.exists(db_file):
+                        self.logger.warning(f"Database file not found: {db_file}")
+                        continue
+                    org_files.append((organism, cspr_file, db_file))
+                    # Store the mapping for later use
+                    index = len(org_files) - 1
+                    self.index_to_cspr[index] = cspr_file
+                    self.index_to_db[index] = db_file
+            self.logger.info(f"Found {len(org_files)} organism files")
         except Exception as e:
+            self.logger.error(f"Error getting organism files: {str(e)}")
+            show_error(self.settings, "Error getting organism files", str(e))
         return org_files
     def get_shared_seeds(self, db_files, limit=False):
         locations = []
         try:
             for db_file in db_files:
+                # Get organism name from CSPR file
+                cspr_file = db_file.replace("_repeats.db", ".cspr")
+                with open(cspr_file, 'r') as f:
+                    organism_name = f.readline().split(":")[-1].strip()
                 with sqlite3.connect(db_file) as conn:
                     c = conn.cursor()
                     for seed in seeds:
                                 locations.append({
                                     'seed': seed,
                                     'sequence': sequence,
+                                    'organism': organism_name,
                                     'chromosome': chrom,
                                     'location': abs(int(locs[i]))
                                 })
+            self.logger.debug(f"Found {len(locations)} locations")
         except Exception as e:
+            self.logger.error(f"Error getting seed locations: {str(e)}")
             show_error(self.global_settings, "Error getting seed locations", str(e))
         return locations
     def get_org_names(self):
+        try:
+            self.org_names = {}
+            for i, cspr_file in self.index_to_cspr.items():
+                with open(cspr_file, 'r') as f:
+                    org_name = f.readline().split(":")[-1].strip()
+                    self.org_names[i] = org_name
+            self.logger.info(f"Loaded {len(self.org_names)} organism names")
+        except Exception as e:
+            self.logger.error(f"Error getting organism names: {str(e)}")
+            show_error(self.settings, "Error getting organism names", str(e))

src/models/ViewTargetsModel.py CHANGED Viewed

@@ -4,13 +4,23 @@ from models.AnnotationParser import AnnotationParser
 import os
 from Bio import SeqIO
 from Bio.Seq import Seq
 class ViewTargetsModel(HomeWindowModel):
     def __init__(self, global_settings):
         super().__init__(global_settings)
         self.targets = []
         self.cspr_parser = None
-        self.annotation_parser = AnnotationParser(global_settings)
         self.gene_sequence = ""
         self.highlighted_sequence = ""
         self.gene_info = {}
@@ -22,175 +32,286 @@ class ViewTargetsModel(HomeWindowModel):
         self.current_gene_end = 0
         self.extended_sequence = ""
         self.chromosome = ""
     def load_targets(self, selected_targets, organism, endonuclease):
-        org_files = self.get_organism_to_files()
-        if organism in org_files and endonuclease in org_files[organism]:
-            cspr_file = org_files[organism][endonuclease][0]
-            cspr_path = os.path.join(self.global_settings.get_db_path(), cspr_file)
-            self.cspr_parser = CSPRparser(cspr_path, self.global_settings.get_casper_info_path())
             self.targets = []
-            self.available_genes = []
             for target in selected_targets:
-                self.chromosome = target['chromosome']  # Store the chromosome
                 chrom = target['chromosome']
                 start, end = map(int, target['location'].split('-'))
-                pos_tuple = (chrom, start, end)
-                cspr_targets = self.cspr_parser.read_targets(target['feature_name'], pos_tuple, endonuclease)
-                self.targets.extend(cspr_targets)
-                if target['feature_name'] not in self.available_genes:
-                    self.available_genes.append(target['feature_name'])
-            if self.available_genes:
-                self._load_gene_data(self.available_genes[0])
-    def _load_gene_data(self, gene_name):
-        annotation_files = self.get_annotation_files()
-        if annotation_files:
-            self.annotation_path = os.path.join(self.global_settings.get_db_path(), 'GBFF', annotation_files[0])
-            self.annotation_parser.set_annotation_file(self.annotation_path)
-            gene_data = self.annotation_parser.get_gene_data(gene_name)
-            print("gene_data", gene_data)
-            if gene_data:
-                self.gene_sequence = gene_data.get('sequence', '')
-                self.gene_info = gene_data.get('info', {})
-                location = self.gene_info.get('feature_location', '')
-                if location:
-                    start, end, strand = self._parse_location(location)
-                    print("strand", strand)
-                    self.current_gene_start = start + 1
-                    self.current_gene_end = end
-                    # Fetch the extended sequence
-                    extended_start = max(0, start - 30)
-                    extended_end = end + 30
-                    extended_seq = self.get_sequence_from_annotation(self.chromosome, extended_start, extended_end)
-                    if strand == '-':
-                        # Reverse complement the entire extended sequence
-                        self.gene_sequence = str(Seq(self.gene_sequence).reverse_complement())
-                        print("self.gene_sequence", self.gene_sequence)
-                    # Create the extended sequence with lowercase placeholders
-                    left_placeholder = extended_seq[:30].lower()
-                    right_placeholder = extended_seq[-30:].lower()
-                    self.gene_sequence = extended_seq[30:-30]
-                    self.extended_sequence = f"{left_placeholder}{self.gene_sequence}{right_placeholder}"
-                self.global_settings.logger.debug(f"Loaded gene sequence for {gene_name}: {self.extended_sequence[:50]}...")
-            else:
-                self.global_settings.logger.warning(f"Gene {gene_name} not found in annotation file")
-    def _parse_location(self, location):
-        parts = location.split(':')
-        start = parts[0]
-        end_strand = parts[1]
-        end = end_strand[:-3]  # Remove the last 3 characters (strand info)
-        strand = end_strand[-2:-1]  # Get the strand info (last 2 characters, excluding the closing parenthesis)
-        return int(start), int(end), strand
-    def get_targets(self):
-        return self.targets
-    def perform_off_target_analysis(self, selected_targets):
-        # Implement off-target analysis here
-        pass
-    def perform_cotargeting(self, selected_targets, endonucleases):
-        # Implement cotargeting analysis here
-        pass
-    def load_gene_viewer_data(self):
-        annotation_files = self.get_annotation_files()
-        if annotation_files:
-            self.annotation_path = os.path.join(self.global_settings.get_db_path(), 'GBFF', annotation_files[0])
-            self.annotation_parser.set_annotation_file(self.annotation_path)
-            self.available_genes = [target['feature_name'] for target in self.targets]
-        else:
-            self.global_settings.logger.warning("No annotation files found.")
-            self.available_genes = []
     def get_gene_data(self, gene_name):
-        self._load_gene_data(gene_name)
-        return {
-            'sequence': self.extended_sequence,
-            'info': self.gene_info,
-            'start': self.current_gene_start,
-            'end': self.current_gene_end
-        }
-    def update_gene_viewer_indices(self, start, end):
-        if start < end and start >= self.current_gene_start and end <= self.current_gene_end:
-            relative_start = start - self.current_gene_start + 30  # Add 30 to account for the left placeholder
-            relative_end = end - self.current_gene_start + 30
-            self.extended_sequence = self.extended_sequence[:30] + self.extended_sequence[relative_start:relative_end] + self.extended_sequence[-30:]
-            return True
-        return False
-    def reset_gene_viewer_indices(self):
-        if self.available_genes:
-            self._load_gene_data(self.available_genes[0])
-    def get_available_genes(self):
-        return self.available_genes
-    def get_gene_sequence(self):
-        return self.gene_sequence
-    def get_highlighted_gene_sequence(self):
-        return self.highlighted_sequence
     def highlight_targets_in_gene_viewer(self, selected_targets):
-        highlighted_sequence = self.extended_sequence
-        for target in selected_targets:
-            sequence = target['sequence']
-            strand = target['strand']
-            if strand == '+':
-                index = highlighted_sequence.upper().find(sequence.upper())
-                if index != -1:
-                    highlighted_sequence = (
-                        highlighted_sequence[:index] +
-                        f"<span style='background-color: green;'>{highlighted_sequence[index:index+len(sequence)]}</span>" +
-                        highlighted_sequence[index+len(sequence):]
-                    )
-            else:  # strand == '-'
-                rev_comp_sequence = str(Seq(sequence).reverse_complement())
-                index = highlighted_sequence.upper().find(rev_comp_sequence.upper())
-                if index != -1:
-                    highlighted_sequence = (
-                        highlighted_sequence[:index] +
-                        f"<span style='background-color: red;'>{highlighted_sequence[index:index+len(rev_comp_sequence)]}</span>" +
-                        highlighted_sequence[index+len(rev_comp_sequence):]
-                    )
-        self.highlighted_sequence = highlighted_sequence
-        return self.highlighted_sequence
-    def get_filter_options(self):
-        return self.filter_options
-    def set_filter_options(self, options):
-        self.filter_options = options
-    def get_scoring_options(self):
-        return self.scoring_options
-    def set_scoring_options(self, options):
-        self.scoring_options = options
-    def get_filtered_targets(self):
-        # Implement filtering logic based on self.filter_options
-        return self.targets
-    def export_targets(self, selected_targets, file_path):
-        # Implement export logic here
-        pass
-    def get_sequence_from_annotation(self, chrom, start, end):
-        for record in SeqIO.parse(self.annotation_path, 'genbank'):
-            if record.id == chrom:
-                return str(record.seq[start:end])
-        return ""

 import os
 from Bio import SeqIO
 from Bio.Seq import Seq
+from functools import lru_cache
+import threading
+from collections import defaultdict
+import re
+import traceback
+import time
+import logging
+from multiprocessing import Pool
+from functools import partial
+from multiprocessing import cpu_count
 class ViewTargetsModel(HomeWindowModel):
     def __init__(self, global_settings):
         super().__init__(global_settings)
         self.targets = []
         self.cspr_parser = None
+        self.annotation_parser = None  # Will be initialized when needed
         self.gene_sequence = ""
         self.highlighted_sequence = ""
         self.gene_info = {}
         self.current_gene_end = 0
         self.extended_sequence = ""
         self.chromosome = ""
+        # Cache structures
+        self._gene_data_cache = {}
+        self._sequence_cache = {}
+        self._parser_cache = {}
+        self._chromosome_seqs = {}
+        self._cached_targets = {}  # Add cache for targets
+    def cleanup(self):
+        """Cleanup method to be called when the view is closed"""
+        try:
+            # Disconnect from annotation file changes
+            if hasattr(self, '_annotation_signal'):
+                self.global_settings.annotation_file_changed.disconnect(self._on_annotation_file_changed)
+                self.global_settings.logger.debug("ViewTargetsModel disconnected from annotation file changes")
+            # Clear caches
+            self._gene_data_cache.clear()
+            self._sequence_cache.clear()
+            self._parser_cache.clear()
+        except Exception as e:
+            self.global_settings.logger.error(f"Error in ViewTargetsModel cleanup: {str(e)}")
+    def _on_annotation_file_changed(self, new_annotation_file):
+        """Clear all caches when annotation file changes"""
+        try:
+            self.global_settings.logger.debug(f"ViewTargetsModel clearing caches for new annotation file: {new_annotation_file}")
+            self._gene_data_cache.clear()
+            self._sequence_cache.clear()
+            self._parser_cache.clear()
+            # Update annotation path and parser
+            self.annotation_path = os.path.join(self.global_settings.get_db_path(), 'GBFF', new_annotation_file)
+            self.annotation_parser = AnnotationParser(self.global_settings)
+            self.annotation_parser.set_annotation_file(self.annotation_path)
+            # Clear other stored data
+            self.gene_sequence = ""
+            self.highlighted_sequence = ""
+            self.gene_info = {}
+            self.available_genes = []
+            self._chromosome_seqs = {}
+        except Exception as e:
+            self.global_settings.logger.error(f"Error in _on_annotation_file_changed: {str(e)}")
     def load_targets(self, selected_targets, organism, endonuclease):
+        """Fast target loading with minimal file operations"""
+        start_time = time.time()
+        try:
+            self.global_settings.logger.debug(f"Starting load_targets with {len(selected_targets)} targets")
+            # Store organism and endonuclease for potential reloading
+            self.organism = organism
+            self.endonuclease = endonuclease
+            # Get CSPR parser from cache or create new one
+            parser_start = time.time()
+            cspr_key = f"{organism}_{endonuclease}"
+            if cspr_key in self._parser_cache:
+                self.cspr_parser = self._parser_cache[cspr_key]
+            else:
+                org_files = self.get_organism_to_files()
+                if organism not in org_files or endonuclease not in org_files[organism]:
+                    self.global_settings.logger.error(f"No CSPR file found for {organism} and {endonuclease}")
+                    return
+                cspr_file = org_files[organism][endonuclease][0]
+                cspr_path = os.path.join(self.global_settings.get_db_path(), cspr_file)
+                self.cspr_parser = CSPRparser(cspr_path, self.global_settings.get_casper_info_path())
+                self._parser_cache[cspr_key] = self.cspr_parser
+            parser_time = time.time() - parser_start
+            # Initialize targets and genes
             self.targets = []
+            self.available_genes = set()
+            # Set up annotation parser if needed
+            if self.annotation_parser is None:
+                annotation_start = time.time()
+                self.annotation_parser = AnnotationParser(self.global_settings)
+                annotation_files = self.get_annotation_files()
+                if annotation_files:
+                    self.annotation_path = os.path.join(self.global_settings.get_db_path(), 'GBFF', annotation_files[0])
+                    self.annotation_parser.set_annotation_file(self.annotation_path)
+                annotation_time = time.time() - annotation_start
+            else:
+                annotation_time = 0
+            # Process targets in batches by chromosome
+            processing_start = time.time()
+            # Group targets by chromosome and prepare batch reading
+            batch_targets = defaultdict(list)
             for target in selected_targets:
                 chrom = target['chromosome']
                 start, end = map(int, target['location'].split('-'))
+                batch_targets[chrom].append({
+                    'feature_name': target['feature_name'],
+                    'start': start,
+                    'end': end
+                })
+                self.available_genes.add(target['feature_name'])
+            # Batch process targets for each chromosome
+            target_count = 0
+            for chrom, targets in batch_targets.items():
+                self.chromosome = chrom
+                # Sort targets by start position for more efficient reading
+                targets.sort(key=lambda x: x['start'])
+                # Read targets in a single batch per chromosome
+                batch_results = self.cspr_parser.read_targets_batch(
+                    chromosome=chrom,
+                    targets=targets,
+                    endonuclease=endonuclease
+                )
+                if batch_results:
+                    self.targets.extend(batch_results)
+                    target_count += len(batch_results)
+            processing_time = time.time() - processing_start
+            # Convert genes to sorted list
+            self.available_genes = sorted(list(self.available_genes))
+            total_time = time.time() - start_time
+            self.global_settings.logger.debug(f"Total load_targets execution time: {total_time:.2f} seconds")
+            self.global_settings.logger.debug(f"Found {target_count} total CSPR targets")
+        except Exception as e:
+            self.global_settings.logger.error(f"Error in load_targets: {str(e)}\n{traceback.format_exc()}")
+            raise
+    def _get_chromosome_sequence(self, chromosome):
+        """Get chromosome sequence on demand"""
+        if not hasattr(self, '_chromosome_seqs'):
+            self._chromosome_seqs = {}
+        if chromosome not in self._chromosome_seqs:
+            for record in SeqIO.parse(self.annotation_path, "genbank"):
+                if record.id == chromosome:
+                    self._chromosome_seqs[chromosome] = str(record.seq)
+                    break
+        return self._chromosome_seqs.get(chromosome)
+    def _initialize_annotation_parser(self):
+        """Initialize annotation parser if not already initialized"""
+        if self.annotation_parser is None:
+            self.annotation_parser = AnnotationParser(self.global_settings)
+            if self.annotation_path:
+                self.annotation_parser.set_annotation_file(self.annotation_path)
     def get_gene_data(self, gene_name):
+        """Get gene data with caching"""
+        try:
+            if not gene_name:
+                self.global_settings.logger.error("No gene name provided")
+                return None
+            # Check model cache first
+            if gene_name in self._gene_data_cache:
+                return self._gene_data_cache[gene_name]
+            # Make sure annotation parser is initialized
+            if self.annotation_parser is None:
+                self._initialize_annotation_parser()
+            # Get gene data from parser
+            gene_data = self.annotation_parser.get_gene_data(gene_name)
+            if gene_data:
+                self._gene_data_cache[gene_name] = gene_data
+            return gene_data
+        except Exception as e:
+            self.global_settings.logger.error(f"Error getting gene data: {str(e)}")
+            return None
+    def get_targets(self):
+        return self.targets
     def highlight_targets_in_gene_viewer(self, selected_targets):
+        """Highlight selected targets in gene viewer"""
+        try:
+            self.global_settings.logger.debug("Starting highlight_targets_in_gene_viewer")
+            sequence = self.extended_sequence
+            if not sequence:
+                self.global_settings.logger.error("No extended sequence available")
+                return sequence
+            self.global_settings.logger.debug(f"Extended sequence length: {len(sequence)}")
+            # Sort targets by position for efficient highlighting
+            highlights = []
+            for target in selected_targets:
+                self.global_settings.logger.debug(f"Processing target: {target}")
+                sequence_to_find = target['sequence']
+                strand = target['strand']
+                # For negative strand, we need to use reverse complement
+                if strand == '-':
+                    sequence_to_find = str(Seq(sequence_to_find).reverse_complement())
+                    self.global_settings.logger.debug(f"Reverse complemented sequence: {sequence_to_find}")
+                # Search for the sequence in the gene viewer text
+                sequence_upper = sequence.upper()
+                target_upper = sequence_to_find.upper()
+                self.global_settings.logger.debug(f"Searching for sequence: {target_upper}")
+                # Find all occurrences
+                pos = sequence_upper.find(target_upper)
+                if pos != -1:
+                    self.global_settings.logger.debug(f"Found sequence at position: {pos}")
+                    color = 'red' if strand == '-' else 'green'
+                    highlights.append((pos, len(sequence_to_find), color))
+                else:
+                    self.global_settings.logger.warning(f"Sequence not found: {target_upper}")
+            if not highlights:
+                self.global_settings.logger.error("No sequences could be highlighted")
+                return sequence
+            self.global_settings.logger.debug(f"Found {len(highlights)} sequences to highlight")
+            # Build highlighted sequence
+            result = []
+            last_pos = 0
+            for pos, length, color in highlights:
+                result.append(sequence[last_pos:pos])
+                result.append(f"<span style='background-color: {color};'>")
+                result.append(sequence[pos:pos+length])
+                result.append("</span>")
+                last_pos = pos + length
+            result.append(sequence[last_pos:])
+            final_sequence = ''.join(result)
+            self.global_settings.logger.debug(f"Final highlighted sequence length: {len(final_sequence)}")
+            return final_sequence
+        except Exception as e:
+            self.global_settings.logger.error(f"Error highlighting targets: {str(e)}\n{traceback.format_exc()}")
+            return sequence
+    def get_available_genes(self):
+        """Get list of available genes from the loaded targets"""
+        try:
+            # Return the available genes list that was populated during load_targets
+            if hasattr(self, 'available_genes'):
+                return self.available_genes
+            # If not already populated, get unique genes from targets
+            genes = set()
+            for target in self.targets:
+                if 'feature_name' in target:
+                    genes.add(target['feature_name'])
+            # Store for future use
+            self.available_genes = sorted(list(genes))
+            return self.available_genes
+        except Exception as e:
+            self.global_settings.logger.error(f"Error getting available genes: {str(e)}")
+            return []
+    # ... (other methods remain unchanged)
+    def _process_target(self, target):
+        """Process a single target - moved to separate method for parallel processing"""
+        try:
+            # Your existing target processing logic here
+            # Make sure to handle any shared resources thread-safely
+            pass
+        except Exception as e:
+            logging.error(f"Error processing target: {e}")
+            return None

src/ui/multitargeting_window.ui CHANGED Viewed

@@ -19,11 +19,19 @@
    <string>MainWindow</string>
   </property>
   <widget class="QWidget" name="centralwidget">
    <layout class="QGridLayout" name="gridLayout_2">
-    <item row="1" column="1">
      <layout class="QGridLayout" name="gridLayout">
-      <item row="2" column="0" rowspan="2">
-       <widget class="QGroupBox" name="groupBox">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
           <horstretch>0</horstretch>
@@ -34,8 +42,8 @@
          <string>Select Organism and Endonuclease:</string>
         </property>
         <layout class="QGridLayout" name="gridLayout_8">
-         <item row="2" column="0">
-          <widget class="QComboBox" name="organism_drop">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
@@ -50,10 +58,10 @@
            </property>
           </widget>
          </item>
-         <item row="3" column="0" colspan="2">
           <layout class="QHBoxLayout" name="horizontalLayout">
            <item>
-            <widget class="QPushButton" name="Analyze_Button">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
                <horstretch>0</horstretch>
@@ -72,7 +80,7 @@
             </widget>
            </item>
            <item>
-            <widget class="QToolButton" name="sql_query_settings">
              <property name="minimumSize">
               <size>
                <width>0</width>
@@ -86,8 +94,8 @@
            </item>
           </layout>
          </item>
-         <item row="1" column="1">
-          <widget class="QLabel" name="label_2">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
@@ -99,8 +107,8 @@
            </property>
           </widget>
          </item>
-         <item row="5" column="0" colspan="2">
-          <widget class="QTableWidget" name="table">
            <property name="minimumSize">
             <size>
              <width>400</width>
@@ -109,8 +117,8 @@
            </property>
           </widget>
          </item>
-         <item row="1" column="0">
-          <widget class="QLabel" name="label">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
@@ -122,8 +130,8 @@
            </property>
           </widget>
          </item>
-         <item row="2" column="1">
-          <widget class="QComboBox" name="endo_drop">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
@@ -138,40 +146,8 @@
            </property>
           </widget>
          </item>
-         <item row="0" column="0" colspan="2">
-          <spacer name="verticalSpacer_3">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
-           </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Fixed</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>10</width>
-             <height>10</height>
-            </size>
-           </property>
-          </spacer>
-         </item>
-         <item row="6" column="0" colspan="2">
-          <spacer name="verticalSpacer_4">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
-           </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Fixed</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>10</width>
-             <height>10</height>
-            </size>
-           </property>
-          </spacer>
-         </item>
-         <item row="4" column="0">
-          <widget class="QCheckBox" name="selectAll">
            <property name="text">
             <string>Select All</string>
            </property>
@@ -180,8 +156,8 @@
         </layout>
        </widget>
       </item>
-      <item row="2" column="1">
-       <widget class="QGroupBox" name="groupBox_2">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="MinimumExpanding">
           <horstretch>0</horstretch>
@@ -198,40 +174,8 @@
          <string>Seed Analysis</string>
         </property>
         <layout class="QGridLayout" name="gridLayout_6">
-         <item row="3" column="0">
-          <spacer name="verticalSpacer_8">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
-           </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Fixed</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>10</width>
-             <height>10</height>
-            </size>
-           </property>
-          </spacer>
-         </item>
          <item row="0" column="0">
-          <spacer name="verticalSpacer_7">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
-           </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Fixed</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>10</width>
-             <height>10</height>
-            </size>
-           </property>
-          </spacer>
-         </item>
-         <item row="1" column="0">
-          <widget class="QTabWidget" name="tabWidget">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
              <horstretch>0</horstretch>
@@ -247,13 +191,13 @@
            <property name="currentIndex">
             <number>0</number>
            </property>
-           <widget class="QWidget" name="tab_3">
             <attribute name="title">
              <string>Scaffold/Chromosome Viewer:</string>
             </attribute>
             <layout class="QGridLayout" name="gridLayout_4">
              <item row="0" column="0">
-              <widget class="QGraphicsView" name="graphicsView_2">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                  <horstretch>0</horstretch>
@@ -269,7 +213,7 @@
               </widget>
              </item>
              <item row="1" column="0">
-              <widget class="QScrollArea" name="scrollArea">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                  <horstretch>0</horstretch>
@@ -279,13 +223,13 @@
                <property name="widgetResizable">
                 <bool>true</bool>
                </property>
-               <widget class="QWidget" name="scrollAreaWidgetContents">
                 <property name="geometry">
                  <rect>
                   <x>0</x>
                   <y>0</y>
-                  <width>424</width>
-                  <height>121</height>
                  </rect>
                 </property>
                </widget>
@@ -293,13 +237,13 @@
              </item>
             </layout>
            </widget>
-           <widget class="QWidget" name="tab_4">
             <attribute name="title">
              <string>Seed Distribution</string>
             </attribute>
             <layout class="QGridLayout" name="gridLayout_9">
              <item row="0" column="0">
-              <widget class="QWidget" name="repeats_vs_chromo" native="true"/>
              </item>
             </layout>
            </widget>
@@ -308,8 +252,8 @@
         </layout>
        </widget>
       </item>
-      <item row="3" column="1">
-       <widget class="QGroupBox" name="groupBox_3">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
           <horstretch>0</horstretch>
@@ -332,24 +276,8 @@
          <string>Global Analysis</string>
         </property>
         <layout class="QGridLayout" name="gridLayout_7">
-         <item row="3" column="0">
-          <spacer name="verticalSpacer_6">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
-           </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Fixed</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>10</width>
-             <height>10</height>
-            </size>
-           </property>
-          </spacer>
-         </item>
-         <item row="1" column="0">
-          <widget class="QPushButton" name="statistics_overview">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
@@ -367,8 +295,8 @@
            </property>
           </widget>
          </item>
-         <item row="2" column="0">
-          <widget class="QTabWidget" name="tabWidget_2">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
              <horstretch>0</horstretch>
@@ -378,23 +306,23 @@
            <property name="currentIndex">
             <number>1</number>
            </property>
-           <widget class="QWidget" name="tab">
             <attribute name="title">
-             <string>Repeats per ID Number</string>
             </attribute>
             <layout class="QGridLayout" name="gridLayout_11">
              <item row="0" column="0">
-              <widget class="QWidget" name="repeats_vs_seeds_line" native="true"/>
              </item>
             </layout>
            </widget>
-           <widget class="QWidget" name="tab_2">
             <attribute name="title">
-             <string>Seeds per Number Repeats</string>
             </attribute>
             <layout class="QGridLayout" name="gridLayout_10">
              <item row="0" column="0">
-              <widget class="QWidget" name="seeds_vs_repeats_bar" native="true">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                  <horstretch>0</horstretch>
@@ -407,41 +335,18 @@
            </widget>
           </widget>
          </item>
-         <item row="0" column="0">
-          <spacer name="verticalSpacer_5">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
-           </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Fixed</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>10</width>
-             <height>10</height>
-            </size>
-           </property>
-          </spacer>
-         </item>
         </layout>
        </widget>
       </item>
       <item row="0" column="0">
-       <widget class="QLabel" name="title">
         <property name="text">
          <string>Multitargeting</string>
         </property>
        </widget>
       </item>
-      <item row="1" column="0" colspan="2">
-       <widget class="Line" name="line">
-        <property name="orientation">
-         <enum>Qt::Horizontal</enum>
-        </property>
-       </widget>
-      </item>
-      <item row="4" column="0" alignment="Qt::AlignLeft">
-       <widget class="QPushButton" name="back_button">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
           <horstretch>0</horstretch>
@@ -459,8 +364,8 @@
         </property>
        </widget>
       </item>
-      <item row="4" column="1" alignment="Qt::AlignRight">
-       <widget class="QPushButton" name="export_button">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
           <horstretch>0</horstretch>
@@ -480,73 +385,8 @@
       </item>
      </layout>
     </item>
-    <item row="1" column="0">
-     <spacer name="horizontalSpacer">
-      <property name="orientation">
-       <enum>Qt::Horizontal</enum>
-      </property>
-      <property name="sizeType">
-       <enum>QSizePolicy::Fixed</enum>
-      </property>
-      <property name="sizeHint" stdset="0">
-       <size>
-        <width>20</width>
-        <height>20</height>
-       </size>
-      </property>
-     </spacer>
-    </item>
-    <item row="2" column="1">
-     <spacer name="verticalSpacer">
-      <property name="orientation">
-       <enum>Qt::Vertical</enum>
-      </property>
-      <property name="sizeType">
-       <enum>QSizePolicy::Fixed</enum>
-      </property>
-      <property name="sizeHint" stdset="0">
-       <size>
-        <width>20</width>
-        <height>20</height>
-       </size>
-      </property>
-     </spacer>
-    </item>
-    <item row="1" column="2">
-     <spacer name="horizontalSpacer_2">
-      <property name="orientation">
-       <enum>Qt::Horizontal</enum>
-      </property>
-      <property name="sizeType">
-       <enum>QSizePolicy::Fixed</enum>
-      </property>
-      <property name="sizeHint" stdset="0">
-       <size>
-        <width>20</width>
-        <height>20</height>
-       </size>
-      </property>
-     </spacer>
-    </item>
-    <item row="0" column="1">
-     <spacer name="verticalSpacer_2">
-      <property name="orientation">
-       <enum>Qt::Vertical</enum>
-      </property>
-      <property name="sizeType">
-       <enum>QSizePolicy::Fixed</enum>
-      </property>
-      <property name="sizeHint" stdset="0">
-       <size>
-        <width>20</width>
-        <height>20</height>
-       </size>
-      </property>
-     </spacer>
-    </item>
    </layout>
   </widget>
-  <widget class="QStatusBar" name="statusbar"/>
  </widget>
  <resources/>
  <connections/>

    <string>MainWindow</string>
   </property>
   <widget class="QWidget" name="centralwidget">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>885</width>
+     <height>564</height>
+    </rect>
+   </property>
    <layout class="QGridLayout" name="gridLayout_2">
+    <item row="0" column="0">
      <layout class="QGridLayout" name="gridLayout">
+      <item row="1" column="0" rowspan="2">
+       <widget class="QGroupBox" name="grpSelectOrganism">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
           <horstretch>0</horstretch>
          <string>Select Organism and Endonuclease:</string>
         </property>
         <layout class="QGridLayout" name="gridLayout_8">
+         <item row="1" column="0">
+          <widget class="QComboBox" name="cmbOrganism">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
            </property>
           </widget>
          </item>
+         <item row="2" column="0" colspan="2">
           <layout class="QHBoxLayout" name="horizontalLayout">
            <item>
+            <widget class="QPushButton" name="pbtnAnalyze">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
                <horstretch>0</horstretch>
             </widget>
            </item>
            <item>
+            <widget class="QToolButton" name="tbtnSQLSettings">
              <property name="minimumSize">
               <size>
                <width>0</width>
            </item>
           </layout>
          </item>
+         <item row="0" column="1">
+          <widget class="QLabel" name="lblEndonuclease">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
            </property>
           </widget>
          </item>
+         <item row="4" column="0" colspan="2">
+          <widget class="QTableWidget" name="tblSeeds">
            <property name="minimumSize">
             <size>
              <width>400</width>
            </property>
           </widget>
          </item>
+         <item row="0" column="0">
+          <widget class="QLabel" name="lblOrganism">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
            </property>
           </widget>
          </item>
+         <item row="1" column="1">
+          <widget class="QComboBox" name="cmbEndonuclease">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
            </property>
           </widget>
          </item>
+         <item row="3" column="0">
+          <widget class="QCheckBox" name="chkSelectAll">
            <property name="text">
             <string>Select All</string>
            </property>
         </layout>
        </widget>
       </item>
+      <item row="1" column="1">
+       <widget class="QGroupBox" name="grpSeedAnalysis">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="MinimumExpanding">
           <horstretch>0</horstretch>
          <string>Seed Analysis</string>
         </property>
         <layout class="QGridLayout" name="gridLayout_6">
          <item row="0" column="0">
+          <widget class="QTabWidget" name="tabsSeedAnalysis">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
              <horstretch>0</horstretch>
            <property name="currentIndex">
             <number>0</number>
            </property>
+           <widget class="QWidget" name="tabChromosomeViewer">
             <attribute name="title">
              <string>Scaffold/Chromosome Viewer:</string>
             </attribute>
             <layout class="QGridLayout" name="gridLayout_4">
              <item row="0" column="0">
+              <widget class="QGraphicsView" name="graphviewChromosome">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                  <horstretch>0</horstretch>
               </widget>
              </item>
              <item row="1" column="0">
+              <widget class="QScrollArea" name="scrollChromosome">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                  <horstretch>0</horstretch>
                <property name="widgetResizable">
                 <bool>true</bool>
                </property>
+               <widget class="QWidget" name="scrollviewChromosome">
                 <property name="geometry">
                  <rect>
                   <x>0</x>
                   <y>0</y>
+                  <width>369</width>
+                  <height>112</height>
                  </rect>
                 </property>
                </widget>
              </item>
             </layout>
            </widget>
+           <widget class="QWidget" name="tabSeedDistribution">
             <attribute name="title">
              <string>Seed Distribution</string>
             </attribute>
             <layout class="QGridLayout" name="gridLayout_9">
              <item row="0" column="0">
+              <widget class="QWidget" name="plotRepeatVsChromosome" native="true"/>
              </item>
             </layout>
            </widget>
         </layout>
        </widget>
       </item>
+      <item row="2" column="1">
+       <widget class="QGroupBox" name="grpGlobalAnalysis">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
           <horstretch>0</horstretch>
          <string>Global Analysis</string>
         </property>
         <layout class="QGridLayout" name="gridLayout_7">
+         <item row="0" column="0">
+          <widget class="QPushButton" name="pbtnStatisticsOverview">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
            </property>
           </widget>
          </item>
+         <item row="1" column="0">
+          <widget class="QTabWidget" name="tabsGlobalAnalysis">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
              <horstretch>0</horstretch>
            <property name="currentIndex">
             <number>1</number>
            </property>
+           <widget class="QWidget" name="tabRepeatsVsSeed">
             <attribute name="title">
+             <string>Repeats per Seed ID Number</string>
             </attribute>
             <layout class="QGridLayout" name="gridLayout_11">
              <item row="0" column="0">
+              <widget class="QWidget" name="plotRepeatsVsSeed" native="true"/>
              </item>
             </layout>
            </widget>
+           <widget class="QWidget" name="tabSequencesVsRepeats">
             <attribute name="title">
+             <string>Sequences per Number Repeats</string>
             </attribute>
             <layout class="QGridLayout" name="gridLayout_10">
              <item row="0" column="0">
+              <widget class="QWidget" name="plotSequencesVsRepeats" native="true">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                  <horstretch>0</horstretch>
            </widget>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="0" column="0">
+       <widget class="QLabel" name="lblMultitargeting">
         <property name="text">
          <string>Multitargeting</string>
         </property>
        </widget>
       </item>
+      <item row="3" column="0" alignment="Qt::AlignLeft">
+       <widget class="QPushButton" name="pbtnBank">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
           <horstretch>0</horstretch>
         </property>
        </widget>
       </item>
+      <item row="3" column="1" alignment="Qt::AlignRight">
+       <widget class="QPushButton" name="pbtnExport">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
           <horstretch>0</horstretch>
       </item>
      </layout>
     </item>
    </layout>
   </widget>
  </widget>
  <resources/>
  <connections/>

src/ui/ncbi_window_v2.ui CHANGED Viewed

@@ -21,16 +21,6 @@
   <widget class="QWidget" name="centralwidget">
    <layout class="QGridLayout" name="gridLayout_2">
     <item row="0" column="0">
-     <widget class="QLabel" name="lblRequired">
-      <property name="text">
-       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;* Required&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-      </property>
-      <property name="alignment">
-       <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-      </property>
-     </widget>
-    </item>
-    <item row="1" column="0">
      <layout class="QGridLayout" name="gridLayout">
       <item row="2" column="0" colspan="2">
        <widget class="QGroupBox" name="grpStep2">

   <widget class="QWidget" name="centralwidget">
    <layout class="QGridLayout" name="gridLayout_2">
     <item row="0" column="0">
      <layout class="QGridLayout" name="gridLayout">
       <item row="2" column="0" colspan="2">
        <widget class="QGroupBox" name="grpStep2">

src/ui/{pop.ui → population_analysis.ui} RENAMED Viewed

@@ -20,88 +20,27 @@
   </property>
   <widget class="QWidget" name="centralwidget">
    <layout class="QGridLayout" name="gridLayout_2">
-    <item row="0" column="1">
-     <spacer name="verticalSpacer">
-      <property name="orientation">
-       <enum>Qt::Vertical</enum>
-      </property>
-      <property name="sizeType">
-       <enum>QSizePolicy::Fixed</enum>
-      </property>
-      <property name="sizeHint" stdset="0">
-       <size>
-        <width>20</width>
-        <height>20</height>
-       </size>
-      </property>
-     </spacer>
-    </item>
-    <item row="1" column="1">
      <layout class="QGridLayout" name="gridLayout">
-      <item row="2" column="0" rowspan="2">
-       <widget class="QGroupBox" name="groupBox">
         <property name="sizePolicy">
-         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
-        <property name="maximumSize">
-         <size>
-          <width>600</width>
-          <height>16777215</height>
-         </size>
-        </property>
         <property name="toolTip">
-         <string>Please select organism(s) and an endonuclease, and click &quot;Analyze Organism(s)&quot; to populate the population analysis window.</string>
         </property>
         <property name="title">
-         <string>Select Organism(s) and Endonuclease:</string>
         </property>
-        <layout class="QGridLayout" name="gridLayout_6">
-         <item row="3" column="0" colspan="2">
-          <widget class="QPushButton" name="analyze_button">
-           <property name="font">
-            <font>
-             <weight>75</weight>
-             <bold>true</bold>
-            </font>
-           </property>
-           <property name="text">
-            <string>Analyze Organism(s)</string>
-           </property>
-          </widget>
-         </item>
-         <item row="0" column="0" colspan="2">
-          <spacer name="verticalSpacer_3">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
-           </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Fixed</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>10</width>
-             <height>10</height>
-            </size>
-           </property>
-          </spacer>
-         </item>
-         <item row="1" column="1">
-          <widget class="QComboBox" name="endoBox">
-           <property name="sizePolicy">
-            <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
-             <horstretch>0</horstretch>
-             <verstretch>0</verstretch>
-            </sizepolicy>
-           </property>
-          </widget>
-         </item>
-         <item row="2" column="0" colspan="2">
-          <widget class="QTableWidget" name="org_Table">
            <property name="sizePolicy">
-            <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
@@ -114,23 +53,47 @@
            </property>
           </widget>
          </item>
-         <item row="1" column="0">
-          <widget class="QLabel" name="label">
            <property name="sizePolicy">
-            <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
-            <string>Endonuclease:</string>
            </property>
           </widget>
          </item>
-         <item row="4" column="0" colspan="2">
-          <widget class="QTabWidget" name="tabWidget">
            <property name="sizePolicy">
-            <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
@@ -142,88 +105,84 @@
             </size>
            </property>
            <property name="toolTip">
-            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Heatmap of shared repeats between all selected organisms. Diagonals show number of self-contained repeats. Axis labels correspond to the rows of the organism selection table.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-           </property>
-           <property name="currentIndex">
-            <number>0</number>
            </property>
-           <widget class="QWidget" name="tab">
-            <attribute name="title">
-             <string>Shared Seed Heatmap</string>
-            </attribute>
-            <layout class="QGridLayout" name="gridLayout_3">
-             <item row="0" column="0">
-              <widget class="QWidget" name="colormap_figure" native="true"/>
-             </item>
-            </layout>
-           </widget>
           </widget>
          </item>
-         <item row="5" column="0" colspan="2">
-          <spacer name="verticalSpacer_4">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
            </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Fixed</enum>
            </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>10</width>
-             <height>10</height>
-            </size>
            </property>
-          </spacer>
          </item>
         </layout>
        </widget>
       </item>
-      <item row="4" column="0" alignment="Qt::AlignLeft">
-       <widget class="QPushButton" name="goBackButton">
         <property name="minimumSize">
          <size>
-          <width>125</width>
           <height>0</height>
          </size>
         </property>
         <property name="text">
-         <string>Back</string>
         </property>
        </widget>
       </item>
-      <item row="2" column="1" rowspan="2">
-       <widget class="QGroupBox" name="groupBox_2">
         <property name="sizePolicy">
-         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="toolTip">
-         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;These tables show the seeds that are conserved among &lt;span style=&quot; font-weight:600;&quot;&gt;all &lt;/span&gt;selected organisms.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="title">
-         <string>Seed Analysis:</string>
         </property>
-        <layout class="QGridLayout" name="gridLayout_5">
-         <item row="4" column="1">
-          <widget class="QPushButton" name="find_locs_button">
-           <property name="text">
-            <string>Find Locations</string>
-           </property>
-          </widget>
-         </item>
-         <item row="2" column="0">
-          <widget class="QPushButton" name="query_seed_button">
-           <property name="text">
-            <string>Query Seed</string>
-           </property>
-          </widget>
-         </item>
-         <item row="3" column="0" colspan="3">
-          <widget class="QTableWidget" name="table2">
            <property name="sizePolicy">
-            <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
@@ -235,57 +194,40 @@
             </size>
            </property>
            <property name="toolTip">
-            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;% Coverage&lt;/span&gt;: percentage of analyzed organisms covered by the given seed sequence. (Ex. a coverage of 75% for an analysis of 4 organisms means that the seed appears in 3/4 of the organisms) &lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Total Repeats&lt;/span&gt;: the total number of times the seed sequence is repeated across all organisms analyzed &lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Avg. Repeats/Scaffold&lt;/span&gt;: the average number of times the seed sequence is repeated per scaffold/chromosome/contig (varies depending on how the organism’s FASTA file is arranged) &lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Consensus Sequence&lt;/span&gt;: the full length guide RNA sequence that appears most commonly amongst all occurrences of the given seed. &lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;% Consensus&lt;/span&gt;: the percentage of all seed repeats that have the tail of the consensus sequence. &lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Score&lt;/span&gt;: on-target score for the consensus sequence.&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;PAM&lt;/span&gt;: the protospacer adjacent motif of the consensus sequence.&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Strand&lt;/span&gt;: the strand directionality (+ or -) of the consensus sequence.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-           </property>
-          </widget>
-         </item>
-         <item row="2" column="2">
-          <widget class="QPushButton" name="clear_Button">
-           <property name="text">
-            <string>Clear Seeds</string>
-           </property>
-          </widget>
-         </item>
-         <item row="1" column="1" colspan="2">
-          <widget class="QLineEdit" name="seed_input"/>
-         </item>
-         <item row="0" column="0" colspan="3">
-          <spacer name="verticalSpacer_5">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
-           </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Fixed</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>10</width>
-             <height>10</height>
-            </size>
            </property>
-          </spacer>
-         </item>
-         <item row="4" column="2">
-          <widget class="QPushButton" name="clear_loc_button">
-           <property name="text">
-            <string>Clear Locations</string>
            </property>
           </widget>
          </item>
-         <item row="4" column="0">
-          <widget class="QLabel" name="label_3">
-           <property name="toolTip">
-            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Highlight a seed and click &amp;quot;Find Locations&amp;quot; to view the exact location and organism of every repeat belonging to that seed.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="text">
-            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Location Finder:&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
           </widget>
          </item>
-         <item row="5" column="0" colspan="3">
-          <widget class="QTableWidget" name="loc_finder_table">
            <property name="sizePolicy">
-            <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
@@ -298,127 +240,49 @@
            </property>
           </widget>
          </item>
-         <item row="1" column="0">
-          <widget class="QLabel" name="label_2">
-           <property name="sizePolicy">
-            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-             <horstretch>0</horstretch>
-             <verstretch>0</verstretch>
-            </sizepolicy>
            </property>
            <property name="text">
-            <string>Seed Search:</string>
            </property>
           </widget>
          </item>
-         <item row="6" column="0" colspan="3">
-          <spacer name="verticalSpacer_6">
-           <property name="orientation">
-            <enum>Qt::Vertical</enum>
-           </property>
-           <property name="sizeType">
-            <enum>QSizePolicy::Fixed</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>10</width>
-             <height>10</height>
-            </size>
            </property>
-          </spacer>
          </item>
         </layout>
        </widget>
       </item>
-      <item row="4" column="1" alignment="Qt::AlignRight">
-       <widget class="QPushButton" name="export_button">
         <property name="minimumSize">
          <size>
-          <width>175</width>
           <height>0</height>
          </size>
         </property>
-        <property name="toolTip">
-         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Click to export selected gRNAs. &lt;span style=&quot; font-weight:600;&quot;&gt;Note: &lt;/span&gt;only rows from the first (top right) table can be selected and exported.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-        </property>
-        <property name="text">
-         <string>Export Selected gRNAs</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="0" colspan="2">
-       <widget class="QLabel" name="title">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
         <property name="text">
-         <string>Population Analysis</string>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="0" colspan="2">
-       <widget class="Line" name="line">
-        <property name="orientation">
-         <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
      </layout>
     </item>
-    <item row="2" column="1">
-     <spacer name="verticalSpacer_2">
-      <property name="orientation">
-       <enum>Qt::Vertical</enum>
-      </property>
-      <property name="sizeType">
-       <enum>QSizePolicy::Fixed</enum>
-      </property>
-      <property name="sizeHint" stdset="0">
-       <size>
-        <width>20</width>
-        <height>20</height>
-       </size>
-      </property>
-     </spacer>
-    </item>
-    <item row="1" column="2">
-     <spacer name="horizontalSpacer">
-      <property name="orientation">
-       <enum>Qt::Horizontal</enum>
-      </property>
-      <property name="sizeType">
-       <enum>QSizePolicy::Fixed</enum>
-      </property>
-      <property name="sizeHint" stdset="0">
-       <size>
-        <width>20</width>
-        <height>20</height>
-       </size>
-      </property>
-     </spacer>
-    </item>
-    <item row="1" column="0">
-     <spacer name="horizontalSpacer_2">
-      <property name="orientation">
-       <enum>Qt::Horizontal</enum>
-      </property>
-      <property name="sizeType">
-       <enum>QSizePolicy::Fixed</enum>
-      </property>
-      <property name="sizeHint" stdset="0">
-       <size>
-        <width>20</width>
-        <height>20</height>
-       </size>
-      </property>
-     </spacer>
-    </item>
    </layout>
   </widget>
-  <widget class="QStatusBar" name="statusbar"/>
  </widget>
  <resources/>
  <connections/>

   </property>
   <widget class="QWidget" name="centralwidget">
    <layout class="QGridLayout" name="gridLayout_2">
+    <item row="0" column="0">
      <layout class="QGridLayout" name="gridLayout">
+      <item row="1" column="1" rowspan="2">
+       <widget class="QGroupBox" name="grpSeedAnalysis">
         <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="toolTip">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;These tables show the seeds that are conserved among &lt;span style=&quot; font-weight:600;&quot;&gt;all &lt;/span&gt;selected organisms.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="title">
+         <string>Seed Analysis:</string>
         </property>
+        <layout class="QGridLayout" name="gridLayout_5">
+         <item row="4" column="0" colspan="3">
+          <widget class="QTableWidget" name="tblLocation">
            <property name="sizePolicy">
+            <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
+         <item row="0" column="0">
+          <widget class="QLabel" name="lblSeedSearch">
            <property name="sizePolicy">
+            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
+            <string>Seed Search:</string>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="0">
+          <widget class="QPushButton" name="pbtnQuerySeed">
+           <property name="text">
+            <string>Query Seed</string>
            </property>
           </widget>
          </item>
+         <item row="3" column="2">
+          <widget class="QPushButton" name="pbtnClearLocations">
+           <property name="text">
+            <string>Clear Locations</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="1" colspan="2">
+          <widget class="QLineEdit" name="ledSeed"/>
+         </item>
+         <item row="1" column="2">
+          <widget class="QPushButton" name="pbtnClearSeeds">
+           <property name="text">
+            <string>Clear Seeds</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="0" colspan="3">
+          <widget class="QTableWidget" name="tblSeed">
            <property name="sizePolicy">
+            <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
             </size>
            </property>
            <property name="toolTip">
+            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;% Coverage&lt;/span&gt;: percentage of analyzed organisms covered by the given seed sequence. (Ex. a coverage of 75% for an analysis of 4 organisms means that the seed appears in 3/4 of the organisms) &lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Total Repeats&lt;/span&gt;: the total number of times the seed sequence is repeated across all organisms analyzed &lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Avg. Repeats/Scaffold&lt;/span&gt;: the average number of times the seed sequence is repeated per scaffold/chromosome/contig (varies depending on how the organism’s FASTA file is arranged) &lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Consensus Sequence&lt;/span&gt;: the full length guide RNA sequence that appears most commonly amongst all occurrences of the given seed. &lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;% Consensus&lt;/span&gt;: the percentage of all seed repeats that have the tail of the consensus sequence. &lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Score&lt;/span&gt;: on-target score for the consensus sequence.&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;PAM&lt;/span&gt;: the protospacer adjacent motif of the consensus sequence.&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Strand&lt;/span&gt;: the strand directionality (+ or -) of the consensus sequence.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
           </widget>
          </item>
+         <item row="3" column="0">
+          <widget class="QLabel" name="lblLocationFInder">
+           <property name="toolTip">
+            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Highlight a seed and click &amp;quot;Find Locations&amp;quot; to view the exact location and organism of every repeat belonging to that seed.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
+           <property name="text">
+            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Location Finder:&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
+          </widget>
+         </item>
+         <item row="3" column="1">
+          <widget class="QPushButton" name="pbtnFindLocations">
+           <property name="text">
+            <string>Find Locations</string>
            </property>
+          </widget>
          </item>
         </layout>
        </widget>
       </item>
+      <item row="0" column="0" colspan="2">
+       <widget class="QLabel" name="lblPopulationAnalysis">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text">
+         <string>Population Analysis</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="1" alignment="Qt::AlignRight">
+       <widget class="QPushButton" name="pbtnExportgRNA">
         <property name="minimumSize">
          <size>
+          <width>175</width>
           <height>0</height>
          </size>
         </property>
+        <property name="toolTip">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Click to export selected gRNAs. &lt;span style=&quot; font-weight:600;&quot;&gt;Note: &lt;/span&gt;only rows from the first (top right) table can be selected and exported.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        </property>
         <property name="text">
+         <string>Export Selected gRNAs</string>
         </property>
        </widget>
       </item>
+      <item row="1" column="0" rowspan="2">
+       <widget class="QGroupBox" name="grpSelectOrganisms">
         <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
+        <property name="maximumSize">
+         <size>
+          <width>600</width>
+          <height>16777215</height>
+         </size>
+        </property>
         <property name="toolTip">
+         <string>Please select organism(s) and an endonuclease, and click &quot;Analyze Organism(s)&quot; to populate the population analysis window.</string>
         </property>
         <property name="title">
+         <string>Select Organism(s) and Endonuclease:</string>
         </property>
+        <layout class="QGridLayout" name="gridLayout_6">
+         <item row="3" column="0" colspan="2">
+          <widget class="QTabWidget" name="tabsSharedSeedHeatmap">
            <property name="sizePolicy">
+            <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
             </size>
            </property>
            <property name="toolTip">
+            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Heatmap of shared repeats between all selected organisms. Diagonals show number of self-contained repeats. Axis labels correspond to the rows of the organism selection table.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
+           <property name="currentIndex">
+            <number>0</number>
            </property>
+           <widget class="QWidget" name="tabSharedSeedHeatmap">
+            <attribute name="title">
+             <string>Shared Seed Heatmap</string>
+            </attribute>
+            <layout class="QGridLayout" name="gridLayout_3">
+             <item row="0" column="0">
+              <widget class="QWidget" name="heatmapSeed" native="true"/>
+             </item>
+            </layout>
+           </widget>
           </widget>
          </item>
+         <item row="0" column="0">
+          <widget class="QLabel" name="lblEndonuclease">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
            </property>
            <property name="text">
+            <string>Endonuclease:</string>
            </property>
           </widget>
          </item>
+         <item row="1" column="0" colspan="2">
+          <widget class="QTableWidget" name="tblOrganism">
            <property name="sizePolicy">
+            <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
+         <item row="2" column="0" colspan="2">
+          <widget class="QPushButton" name="pbtnAnalyzeOrganism">
+           <property name="font">
+            <font>
+             <weight>75</weight>
+             <bold>true</bold>
+            </font>
            </property>
            <property name="text">
+            <string>Analyze Organism(s)</string>
            </property>
           </widget>
          </item>
+         <item row="0" column="1">
+          <widget class="QComboBox" name="cmbEndonuclease">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
            </property>
+          </widget>
          </item>
         </layout>
        </widget>
       </item>
+      <item row="3" column="0" alignment="Qt::AlignLeft">
+       <widget class="QPushButton" name="pbtnBack">
         <property name="minimumSize">
          <size>
+          <width>125</width>
           <height>0</height>
          </size>
         </property>
         <property name="text">
+         <string>Back</string>
         </property>
        </widget>
       </item>
      </layout>
     </item>
    </layout>
   </widget>
  </widget>
  <resources/>
  <connections/>

src/utils/ui.py CHANGED Viewed

@@ -35,13 +35,8 @@ def show_error(settings, message, e):
 def scale_ui(window, base_width=1920, base_height=1080, font_size=12, header_font_size=30, custom_scale_width=None, custom_scale_height=None):
     try:
-        window.repaint()
-        QtWidgets.QApplication.processEvents()
         # Get the primary screen
         screen = QtGui.QGuiApplication.primaryScreen()
-        # Get the geometry of the screen
         screen_geometry = screen.geometry()
         width = screen_geometry.width()
         height = screen_geometry.height()
@@ -53,31 +48,25 @@ def scale_ui(window, base_width=1920, base_height=1080, font_size=12, header_fon
             scaled_title_font_size = int(header_font_size * (width / base_width))
             window.title.setStyleSheet(f"font: bold {scaled_title_font_size}pt 'Arial';")
-        window.adjustSize()
         currentWidth = window.size().width()
         currentHeight = window.size().height()
-        # Window resize and center
-        scaledWidth = int((width * (custom_scale_width if custom_scale_width else 1150)) / base_width)
-        scaledHeight = int((height * (custom_scale_height if custom_scale_height else 650)) / base_height)
         if scaledHeight < currentHeight:
             scaledHeight = currentHeight
         if scaledWidth < currentWidth:
             scaledWidth = currentWidth
-        # Center the window on the screen
-        centerPoint = screen_geometry.center()
-        x = centerPoint.x() - (scaledWidth // 2)
-        y = centerPoint.y() - (scaledHeight // 2)
-        window.setGeometry(x, y, scaledWidth, scaledHeight)
-        window.repaint()
-        QtWidgets.QApplication.processEvents()
     except Exception as e:
-        print(f"Error in scale_ui: {e}")
 def center_ui(window):
     try:

 def scale_ui(window, base_width=1920, base_height=1080, font_size=12, header_font_size=30, custom_scale_width=None, custom_scale_height=None):
     try:
         # Get the primary screen
         screen = QtGui.QGuiApplication.primaryScreen()
         screen_geometry = screen.geometry()
         width = screen_geometry.width()
         height = screen_geometry.height()
             scaled_title_font_size = int(header_font_size * (width / base_width))
             window.title.setStyleSheet(f"font: bold {scaled_title_font_size}pt 'Arial';")
+        # Calculate sizes
+        scaledWidth = int((width * (custom_scale_width if custom_scale_width else 1150)) / base_width)
+        scaledHeight = int((height * (custom_scale_height if custom_scale_height else 650)) / base_height)
+        # Ensure minimum size
+        window.adjustSize()
         currentWidth = window.size().width()
         currentHeight = window.size().height()
         if scaledHeight < currentHeight:
             scaledHeight = currentHeight
         if scaledWidth < currentWidth:
             scaledWidth = currentWidth
+        # Resize in a single operation
+        window.resize(scaledWidth, scaledHeight)
     except Exception as e:
+        print(f"Error in scale_ui: {e}")
 def center_ui(window):
     try:

src/views/AnnotationParser.py DELETED Viewed

@@ -1,429 +0,0 @@
-###############################################################################
-# INPUTS: inputs are the annotation files to parse. Currently, only gbff is supported.
-# OUTPUTS: the outputs are data structures that store the parsed data
-################################################################################
-from PyQt5 import QtWidgets
-import gffutils
-import models.GlobalSettings as GlobalSettings
-import os
-from Bio import SeqIO
-import traceback
-logger = GlobalSettings.logger
-class Annotation_Parser:
-    def __init__(self):
-        try:
-            #variables to use
-            self.annotationFileName = "" #this is the variable that holds the filename itself
-            self.txtLocusTag = False
-            self.isGff = False
-            self.isTxt = False
-            self.max_chrom = 0
-            #dictionary used for finding the genes in a txt annotation file
-            #key: locus_tag
-            #value: List of lists
-            #   essentially its all based on locus tag. So the key is the locus tag, and its data is:
-            #       [genomic accession, int, start, end, +\-]
-            self.reg_dict = dict()
-            #parallel dictionary used for the txt annotaion file
-            #key: name + symbol (space in between each word)
-            #value: locus_tag (indexes dict)
-            self.para_dict = dict()
-            #list of tuples containing (chromosome/scaffold # {int}, Feature matching search criteria {SeqFeature Object})
-            self.results_list = list()
-        except Exception as e:
-            logger.critical("Error initializing Annotation_Parser class.")
-            logger.critical(e)
-            logger.critical(traceback.format_exc())
-            msgBox = QtWidgets.QMessageBox()
-            msgBox.setStyleSheet("font: " + str(GlobalSettings.mainWindow.fontSize) + "pt 'Arial'")
-            msgBox.setIcon(QtWidgets.QMessageBox.Icon.Critical)
-            msgBox.setWindowTitle("Fatal Error")
-            msgBox.setText("Fatal Error:\n"+str(e)+ "\n\nFor more information on this error, look at CASPER.log in the application folder.")
-            msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Close)
-            msgBox.exec()
-            exit(-1)
-    ### This function takes a list of lists and flattens it into a single list. Useful when dealing with a list of lists where the nested lists only have 1 entry.
-    def flatten_list(self,t):
-        return [item.lower() for sublist in t for item in sublist]
-    ### This function finds how many chromosomes are within the selcted annotation file and returns the value
-    def get_max_chrom(self):
-        parser = SeqIO.parse(self.annotationFileName, 'genbank') # Initialize parser (iterator) for each query
-        for i, record in enumerate(parser):
-            max_chrom = i+1
-        return max_chrom
-    def get_sequence_info(self, query):
-        try:
-            self.results_list.clear()
-            parser = SeqIO.parse(self.annotationFileName, 'genbank') # Initialize parser (iterator) for each query
-            for j,record in enumerate(parser): # Each record corresponds to a chromosome/scaffold in the FNA/FASTA file
-                tmp = str(record.seq).find(query)
-                if tmp != -1: # If match is found
-                    return (j+1,tmp+1,tmp+len(query)) # Chromosome number, start index, stop index
-                else:
-                    tmp = str(record.seq.reverse_complement()).find(query) # Check the reverse complement now
-                    if tmp != -1: # If match is found
-                        return (j+1,tmp-len(query),tmp-1) # Chromosome number, start index, stop index
-                    else:
-                        continue
-            return False
-        except Exception as e:
-            logger.critical("Error in get_sequence_info() in annotation parser.")
-            logger.critical(e)
-            logger.critical(traceback.format_exc())
-            msgBox = QtWidgets.QMessageBox()
-            msgBox.setStyleSheet("font: " + str(GlobalSettings.mainWindow.fontSize) + "pt 'Arial'")
-            msgBox.setIcon(QtWidgets.QMessageBox.Icon.Critical)
-            msgBox.setWindowTitle("Fatal Error")
-            msgBox.setText("Fatal Error:\n"+str(e)+ "\n\nFor more information on this error, look at CASPER.log in the application folder.")
-            msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Close)
-            msgBox.exec()
-            exit(-1)
-    ### The workhorse function of AnnotationParser, this searches the annotation file for the user's search and returns features matching the description.
-    def genbank_search(self, queries, same_search):
-        index_number = 0
-        try:
-            if same_search: # If searching for the same thing, just return the results from last time
-                return self.results_list
-            else:
-                self.results_list.clear()
-                for i, query in enumerate(queries):
-                    parser = SeqIO.parse(self.annotationFileName, 'genbank') # Initialize parser (iterator) for each query
-                    for j,record in enumerate(parser): # Each record corresponds to a chromosome/scaffold in the FNA/FASTA file
-                        if i == 0:
-                            index_number += 1
-                            for feature in record.features: # Each feature corresponds to a gene, tRNA, rep_origin, etc. in the given record (chromosome/scaffold)
-                                if "translation" in feature.qualifiers:
-                                    if query.lower() in " ".join(self.flatten_list(feature.qualifiers.values())[:-1]) and feature.type != "source" and feature.type != "gene": # If search matches the feature's qualifiers somewhere, save it
-                                        self.results_list.append((j+1,feature))
-                                    else: # If search not in the feature's qualifiers, move to the next feature
-                                        continue
-                                else:
-                                    if query.lower() in " ".join(self.flatten_list(feature.qualifiers.values())) and feature.type != "source" and feature.type != "gene": # If search matches the feature's qualifiers somewhere, save it
-                                        self.results_list.append((j+1,feature))
-                                    else: # If search not in the feature's qualifiers, move to the next feature
-                                        continue
-                            self.max_chrom = index_number # Counts the number of chromosomes/scaffolds in the organism (only do this once, even if there are multiple queries)
-                        else:
-                            for feature in record.features:
-                                if "translation" in feature.qualifiers:
-                                    if query.lower() in " ".join(self.flatten_list(feature.qualifiers.values())[:-1]) and feature.type != "source" and feature.type != "gene": # If search matches the feature's qualifiers somewhere, save it
-                                        self.results_list.append((j+1,feature))
-                                    else: # If search not in the feature's qualifiers, move to the next feature
-                                        continue
-                                else:
-                                    if query.lower() in " ".join(self.flatten_list(feature.qualifiers.values())) and feature.type != "source" and feature.type != "gene": # If search matches the feature's qualifiers somewhere, save it
-                                        self.results_list.append((j+1,feature))
-                                    else: # If search not in the feature's qualifiers, move to the next feature
-                                        continue
-                return self.results_list
-        except Exception as e:
-            logger.critical("Error in genbank_search() in annotation parser.")
-            logger.critical(e)
-            logger.critical(traceback.format_exc())
-            msgBox = QtWidgets.QMessageBox()
-            msgBox.setStyleSheet("font: " + str(GlobalSettings.mainWindow.fontSize) + "pt 'Arial'")
-            msgBox.setIcon(QtWidgets.QMessageBox.Icon.Critical)
-            msgBox.setWindowTitle("Fatal Error")
-            msgBox.setText("Fatal Error:\n"+str(e)+ "\n\nFor more information on this error, look at CASPER.log in the application folder.")
-            msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Close)
-            msgBox.exec()
-            exit(-1)
-    # This function parses gff files and stores them in a dictionary
-    # It also creates a parallel dictionary to use in searching
-    # Precondition: ONLY TO BE USED WITH GFF FILES
-    def gff_parse(self):
-        try:
-            self.reg_dict.clear()
-            self.para_dict.clear()
-            prevFirstIndex = ""
-            indexNumber = 1
-            fileStream = open(self.annotationFileName)
-            data_base_file_name = GlobalSettings.CSPR_DB + "/" + "gff_database.db"
-            # temp list will be the following each time it is put into the dictionary:
-            # [Sequence ID (genomic accession or scaffold), the index number itself, the feature type (cds, gene, mrna), the start(-1), end, and the strand]
-            tempList = list()
-            currentLocusTag = ""
-            para_dict_key_string = ""
-            # initialize the data base (this is what parses it for me)
-            print("Intializing the data base")
-            db = gffutils.create_db(self.annotationFileName, dbfn=data_base_file_name, force=True, keep_order=True,
-                                    merge_strategy='merge', sort_attribute_values=True)
-            print("Finished intializing")
-            # call the feature version of that data base now
-            db = gffutils.FeatureDB(data_base_file_name, keep_order=True)
-            # now we go through that data base and get the data we want
-            for feature in db.all_features(limit=None, strand=None, featuretype=None, order_by=None, reverse=False,
-                                           completely_within=False):
-                # if the genomic accession/scaffold/chromseome changes, update the indexNumber
-                if prevFirstIndex != feature.seqid and prevFirstIndex != "":
-                    indexNumber += 1
-                # if we find a new gene, update the locus_tag/name
-                if feature.featuretype == "gene" or feature.featuretype == 'pseudogene':
-                    # check and see if locus tag is in the attributes, go on the Name if locus_tag is not in there
-                    if 'locus_tag' in feature.attributes:
-                        currentLocusTag = feature.attributes['locus_tag'][0]
-                    else:
-                        currentLocusTag = feature.attributes["Name"][0]
-                    # once the locus tag changes, append it to the para_dict
-                    if para_dict_key_string != "":
-                        if para_dict_key_string not in self.para_dict:
-                            self.para_dict[para_dict_key_string] = list()
-                            self.para_dict[para_dict_key_string].append(currentLocusTag)
-                        else:
-                            if currentLocusTag not in self.para_dict[para_dict_key_string]:
-                                self.para_dict[para_dict_key_string].append(currentLocusTag)
-                        para_dict_key_string = ""
-                    tempList = [currentLocusTag, indexNumber, feature.featuretype, feature.start - 1, feature.end,
-                                feature.strand]
-                    # insert that locus tag/name into the dictionary
-                    if currentLocusTag not in self.reg_dict:
-                        self.reg_dict[currentLocusTag] = []
-                        self.reg_dict[currentLocusTag].append(tempList)
-                    elif currentLocusTag in self.reg_dict:
-                        self.reg_dict[currentLocusTag].append(tempList)
-                    # go through each of this child's children
-                    for child in db.children(feature.id, level=None, featuretype=None, order_by=None, reverse=False,
-                                             limit=None, completely_within=False):
-                        tempList = [currentLocusTag, indexNumber, child.featuretype, child.start - 1, child.end, child.strand]
-                        # only insert it if it hasn't been inserted before
-                        if tempList not in self.reg_dict[currentLocusTag]:
-                            self.reg_dict[currentLocusTag].append(tempList)
-                # now go through the other ones which are not region
-                elif feature.featuretype != "region" and feature.featuretype != "telomere" and feature.featuretype != "origin_of_replication":
-                    tempList = [currentLocusTag, indexNumber, feature.featuretype, feature.start - 1, feature.end,
-                                feature.strand]
-                    # only insert if it hasn't been inserted before
-                    if tempList not in self.reg_dict[currentLocusTag]:
-                        self.reg_dict[currentLocusTag].append(tempList)
-                        # now same as above, go through the children again
-                        for child in db.children(feature.id, level=None, featuretype=None, order_by=None, reverse=False,
-                                                 limit=None, completely_within=False):
-                            tempList = [currentLocusTag, indexNumber, child.featuretype, child.start - 1, child.end,
-                                        child.strand]
-                            if tempList not in self.reg_dict[currentLocusTag]:
-                                self.reg_dict[currentLocusTag].append(tempList)
-                # now we need to get the para_dict up and running
-                # get the stuff out of the product part
-                if 'product' in feature.attributes and feature.featuretype == "CDS":
-                    if para_dict_key_string == "":
-                        para_dict_key_string = feature.attributes['product'][0]
-                    else:
-                        para_dict_key_string = para_dict_key_string + ";" + feature.attributes['product'][0]
-                # get the stuff out of the Note part
-                if 'Note' in feature.attributes:
-                    if para_dict_key_string == "":
-                        para_dict_key_string = feature.attributes['Note'][0]
-                    else:
-                        para_dict_key_string = para_dict_key_string + ";" + feature.attributes['Note'][0]
-                prevFirstIndex = feature.seqid
-            self.max_chrom = indexNumber
-        except Exception as e:
-            logger.critical("Error in gff_parse() in annotation parser.")
-            logger.critical(e)
-            logger.critical(traceback.format_exc())
-            msgBox = QtWidgets.QMessageBox()
-            msgBox.setStyleSheet("font: " + str(GlobalSettings.mainWindow.fontSize) + "pt 'Arial'")
-            msgBox.setIcon(QtWidgets.QMessageBox.Icon.Critical)
-            msgBox.setWindowTitle("Fatal Error")
-            msgBox.setText("Fatal Error:\n"+str(e)+ "\n\nFor more information on this error, look at CASPER.log in the application folder.")
-            msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Close)
-            msgBox.exec()
-            exit(-1)
-    # This function parses txt files and stores them in a dictionary
-    # It also creates a parallel dictionary to use in searching
-    # Precondition: ONLY TO BE USED WITH TXT FILES
-    def txt_parse(self):
-        try:
-            self.reg_dict.clear()
-            prevGenAccession = ""
-            indexNumber = 1
-            fileStream = open(self.annotationFileName)
-            buffer = ""
-            currentLocusTag = ""
-            para_dict_key_string = ""
-            while(True): # this loop breaks out when buffer string is empty
-                buffer = fileStream.readline()
-                if(buffer.startswith("#")): #skip lines that start with #
-                    continue
-                else:
-                    if(len(buffer) <= 2): # break out once we reach the end of the file
-                        break
-                    splitLine = buffer[:-1].split("\t")
-                    # increment indexNumber when genomic access changes
-                    if prevGenAccession != splitLine[6] and prevGenAccession != "":
-                        indexNumber += 1
-                    # if parsing on locus_tag, use the locus_tag as the key for the dict
-                    if self.txtLocusTag:
-                        currentLocusTag = splitLine[16]
-                        values = [currentLocusTag, indexNumber, splitLine[0], int(splitLine[7]) - 1, int(splitLine[8]), splitLine[9]]
-                        if currentLocusTag not in self.reg_dict:
-                            self.reg_dict[currentLocusTag] = [values]
-                        elif currentLocusTag in self.reg_dict:
-                            self.reg_dict[currentLocusTag].append(values)
-                    # if no locus_tag, parse on product_accession, use the product_accession as the key for the dict
-                    elif not self.txtLocusTag:
-                        currentLocusTag = splitLine[10]
-                        values = [currentLocusTag, indexNumber, splitLine[0], int(splitLine[7]) - 1, int(splitLine[8]), splitLine[9]]
-                        if currentLocusTag not in self.reg_dict:
-                            self.reg_dict[currentLocusTag] = [values]
-                        elif currentLocusTag in self.reg_dict:
-                            self.reg_dict[currentLocusTag].append(values)
-                    if splitLine[13] != '':
-                        if para_dict_key_string == '':
-                            para_dict_key_string = splitLine[13] + ';'
-                        else:
-                            para_dict_key_string = para_dict_key_string + splitLine[13] + ';'
-                    # leaving this in for now, it's related accession
-                    #if splitLine[12] != '':
-                     #   if para_dict_key_string == '':
-                    #        para_dict_key_string = splitLine[12] + ';'
-                     #   else:
-                     #       para_dict_key_string = para_dict_key_string + splitLine[12] + ';'
-                    if splitLine[14] != '':
-                        if para_dict_key_string == '':
-                            para_dict_key_string = splitLine[14] + ';'
-                        else:
-                            para_dict_key_string = para_dict_key_string + splitLine[14] + ';'
-                    para_dict_key_string = para_dict_key_string.replace(',', '')
-                    # set the parallel dictionary's key string
-                    #para_dict_key_string = splitLine[13] + ";" + splitLine[12] + ";" + splitLine[14]
-                    # if the current line we're on has the data we want for the parellel dictionary, store it
-                    if len(para_dict_key_string) > 3:
-                        if para_dict_key_string[len(para_dict_key_string) - 1] == ';':
-                            para_dict_key_string = para_dict_key_string[0:len(para_dict_key_string) - 1]
-                        if para_dict_key_string not in self.para_dict: # make a new input into the dict
-                            self.para_dict[para_dict_key_string] = [currentLocusTag]
-                        elif para_dict_key_string in self.para_dict:
-                            if currentLocusTag not in self.para_dict[para_dict_key_string]:
-                                # only append it to the dict's list if it isn't currently in there
-                                self.para_dict[para_dict_key_string].append(currentLocusTag)
-                    para_dict_key_string = ""
-                    prevGenAccession = splitLine[6]
-            self.max_chrom = indexNumber
-        except Exception as e:
-            logger.critical("Error in txt_parse() in annotation parser.")
-            logger.critical(e)
-            logger.critical(traceback.format_exc())
-            msgBox = QtWidgets.QMessageBox()
-            msgBox.setStyleSheet("font: " + str(GlobalSettings.mainWindow.fontSize) + "pt 'Arial'")
-            msgBox.setIcon(QtWidgets.QMessageBox.Icon.Critical)
-            msgBox.setWindowTitle("Fatal Error")
-            msgBox.setText("Fatal Error:\n"+str(e)+ "\n\nFor more information on this error, look at CASPER.log in the application folder.")
-            msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Close)
-            msgBox.exec()
-            exit(-1)
-    # This function checks to see which file we are parsing
-    # It also checks whether to parse based on locus_tag or product accession (txt files only)
-    # Then it calls the respective parser functions used
-    def find_which_file_version(self):
-        try:
-            if self.annotationFileName == "" or GlobalSettings.mainWindow.annotation_files.currentText() == "None":
-                return -1
-            if "gff" in self.annotationFileName:
-                ### gff file support currently deprecated
-                """
-                self.isGff = True
-                self.gff_parse()
-                """
-                print("Error: Wrong annotation file format")
-                return -1
-            elif "feature_table" in self.annotationFileName:
-                ### feature table file support currently deprecated
-                # now that we know it's a txt file and not a gff, check and see if we will be parsing by locus tag or
-                # product accession
-                """
-                fileStream = open(self.annotationFileName)
-                #skip all of the lines that start with #
-                buf = fileStream.readline()
-                while buf.startswith("#"):
-                    buf = fileStream.readline()
-                # split it and see if the locus tag spot has data in it
-                split = buf.split("\t")
-                if split[16] != "": # if it does, we are parsing based on locus_tag
-                    self.txtLocusTag = True
-                elif split[16] == "": # if not, we are parsing based on product accession
-                    self.txtLocusTag = False
-                fileStream.close()
-                self.isTxt = True
-                self.txt_parse()
-                """
-                print("Error: Wrong annotation file format")
-                return -1
-            elif "gbff" or "gbk" in self.annotationFileName:
-                return "gbff"
-            # return -1 to throw the error window in main
-            else:
-                return -1
-        except Exception as e:
-            logger.critical("Error in find_which_file_version() in annotation parser.")
-            logger.critical(e)
-            logger.critical(traceback.format_exc())
-            msgBox = QtWidgets.QMessageBox()
-            msgBox.setStyleSheet("font: " + str(GlobalSettings.mainWindow.fontSize) + "pt 'Arial'")
-            msgBox.setIcon(QtWidgets.QMessageBox.Icon.Critical)
-            msgBox.setWindowTitle("Fatal Error")
-            msgBox.setText("Fatal Error:\n"+str(e)+ "\n\nFor more information on this error, look at CASPER.log in the application folder.")
-            msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Close)
-            msgBox.exec()
-            exit(-1)

src/views/CMainWindow.py DELETED Viewed

@@ -1,987 +0,0 @@
-import platform
-# import controllers.ncbi as ncbi
-import os
-# from utils.Algorithms import get_table_headers
-# from models.CSPRparser import CSPRparser
-import glob
-import models.GlobalSettings as GlobalSettings
-from PyQt6 import QtWidgets, QtGui, QtCore, uic, QtGui
-from utils.ui import scale_ui, center_ui, show_message, show_error
-# from views.annotation_functions import *
-# from views.AnnotationParser import Annotation_Parser
-# from views.AnnotationWindow import AnnotationWindow
-# import views.genomeBrowser as genomeBrowser
-# from views.NewGenome import NewGenome
-# from views.NewEndonuclease import NewEndonuclease
-# from controllers.CoTargeting import CoTargeting
-# from views.generateLib import genLibrary
-# from controllers.Results import Results
-# from views.export_tool import export_tool
-# from views.closingWin import closingWindow
-# from utils.web import ncbi_page, repo_page, ncbi_blast_page
-# from controllers.populate_fna_files import PopulateFNAFiles
-# logger = GlobalSettings.logger
-fontSize = 12
-class CMainWindow(QtWidgets.QMainWindow):
-    def __init__(self, settings):
-        try:
-            super(CMainWindow, self).__init__()
-            # uic.loadUi(os.path.join(self.settings.get_ui_dir(), 'startupCASPER.ui'), self)
-            # uic.loadUi(GlobalSettings.appdir + 'ui/CASPER_main.ui', self)
-            # print("path: ", GlobalSettings.appdir + 'ui/CASPER_main_copy_2.ui')
-            # uic.loadUi(GlobalSettings.appdir + 'ui/CASPER_main_copy_2.ui', self)
-            self.settings = settings
-            print("path: ", os.path.join(self.settings.get_ui_dir(), 'CASPER_main.ui'))
-            uic.loadUi(os.path.join(self.settings.get_ui_dir(), 'CASPER_main.ui'), self)
-            self.setWindowTitle("CASPER")
-            self.setWindowIcon(QtGui.QIcon(os.path.join(self.settings.get_assets_dir(), "cas9image.ico")))
-            # self.dbpath = ""
-            # self.inputstring = "" # This is the search string
-            # # self.info_path = settings.get_app_dir()
-            # # info_path = settings.get_app_dir()
-            # self.anno_name = ""
-            # self.endo_name = ""
-            # self.fontSize = 12
-            # self.org = ""
-            # self.TNumbers = {}  # the T numbers from a kegg search
-            # self.orgcodes = {}  # Stores the Kegg organism code by the format {full name : organism code}
-            # self.gene_list = {}  # list of genes (no ides what they pertain to
-            # self.searches = {}
-            # self.checkBoxes = []
-            # self.genlib_list = [] # This list stores selected SeqFeatures from annotation window
-            # self.checked_info = {}
-            # self.check_ntseq_info = {}  # the ntsequences that go along with the checked_info
-            # self.annotation_parser = Annotation_Parser()
-            # self.link_list = list()  # the list of the downloadable links from the NCBI search
-            # self.organismDict = dict()  # the dictionary for the links to download. Key is the description of the organism, value is the ID that can be found in link_list
-            # self.results_list = list()
-            # self.organismData = list()
-            # self.ncbi = ncbi.NCBI_search_tool()
-            # groupbox_style = """
-            # QGroupBox:title{subcontrol-origin: margin;
-            #                 left: 10px;
-            #                 padding: 0 5px 0 5px;}
-            # QGroupBox#Step1{border: 2px solid rgb(111,181,110);
-            #                 border-radius: 9px;
-            #                 margin-top: 10px;
-            #                 font: bold 14pt 'Arial';}
-            #                 """
-            # self.Step1.setStyleSheet(groupbox_style)
-            # self.Step2.setStyleSheet(groupbox_style.replace("Step1", "Step2"))
-            # self.Step3.setStyleSheet(groupbox_style.replace("Step1", "Step3"))
-            # self.CASPER_Navigation.setStyleSheet(groupbox_style.replace("Step1", "CASPER_Navigation").replace("solid","dashed").replace("rgb(111,181,110)","rgb(88,89,91)"))
-            # self.setWindowIcon(QtGui.QIcon(GlobalSettings.appdir + "cas9image.ico"))
-            # self.pushButton_FindTargets.clicked.connect(self.gather_settings)
-            # self.pushButton_ViewTargets.clicked.connect(self.view_results)
-            # self.pushButton_ViewTargets.setEnabled(False)
-            # self.GenerateLibrary.setEnabled(False)
-            # self.radioButton_Gene.clicked.connect(self.toggle_annotation)
-            # self.radioButton_Position.clicked.connect(self.toggle_annotation)
-            """ Connect functions to buttons """
-            # self.newGenome_button.clicked.connect(self.launch_newGenome) # Connect launch function to New Genome
-            # self.newEndo_button.clicked.connect(self.launch_newEndonuclease) # Connect launch function to New Endonuclease
-            # self.multitargeting_button.clicked.connect(self.changeto_multitargeting) # Connect launch function to Multitargeting
-            # self.populationAnalysis_button.clicked.connect(self.changeto_population_Analysis) # Connect launch function to PA
-            # self.GenerateLibrary.clicked.connect(self.prep_genlib)
-            # self.combineFiles_button.clicked.connect(self.launch_populate_fna_files)
-            """ Connect functions to actions (menu bar) """
-            # self.actionOpen_Genome_Browser.triggered.connect(self.launch_newGenomeBrowser)
-            # self.actionExit.triggered.connect(self.close_app)
-            # self.visit_repo.triggered.connect(repo_page)
-            # self.actionChange_Directory.triggered.connect(self.change_directory)
-            # self.actionNCBI.triggered.connect(ncbi_page)
-            # self.actionCasper2.triggered.connect(self.open_casper2_web_page)
-            # self.actionNCBI_BLAST.triggered.connect(ncbi_blast_page)
-            # self.progressBar.setMinimum(0)
-            # self.progressBar.setMaximum(100)
-            # self.progressBar.reset()
-            # self.Annotation_Window = AnnotationWindow(info_path)
-            # self.geneEntryField.setPlaceholderText("Example Inputs: \n\n"
-            #                                 "Option 1: Feature (ID, Locus Tag, or Name)\n"
-            #                                 "Example: 854068/YOL086C/ADH1 for S. cerevisiae alcohol dehydrogenase 1\n\n"
-            #                                 "Option 2: Position (chromosome,start,stop)\n"
-            #                                 "Example: 1,1,1000 for targeting chromosome 1, base pairs 1 to 1000\n\n"
-            #                                 "Option 3: Sequence (must be within the selected organism)\n"
-            #                                 "Example: Any nucleotide sequence between 100 and 10,000 base pairs.\n\n"
-            #                                 "*Note: to multiplex, separate multiple queries by new lines*\n"
-            #                                 "Example:\n"
-            #                                 "1,1,1000\n"
-            #                                 "5,1,500\n"
-            #                                 "etc.")
-            # show functionalities on window
-            self.populate_fna_files = None
-            self._new_genome = None
-            # self.newEndonuclease = NewEndonuclease()
-            # self.CoTargeting = CoTargeting(info_path)
-            # self.Results = Results()
-            # self.export_tool_window = export_tool()
-            # self.genLib = genLibrary()
-            # self.myClosingWindow = closingWindow()
-            # self.genomebrowser = genomeBrowser.genomebrowser()
-            # self.launch_ncbi_button.clicked.connect(self.launch_ncbi)
-            # self.first_show = True
-            scale_ui(self, custom_scale_width=1150, custom_scale_height=650)
-            # self.show()
-            # self.load_dropdown_data()
-            print("MainWindow initialized")
-        except Exception as e:
-            show_error("Error in __init__() in main", e)
-    # def get_populate_fna_files(self):
-    #     if self.populate_fna_files is None:
-    #         self.populate_fna_files = PopulateFNAFiles(GlobalSettings.GlobalSettings1(GlobalSettings.appdir))
-    #     return self.populate_fna_files
-    # def launch_populate_fna_files(self):
-    #     self.get_populate_fna_files().show()  # Ensure the window is shown
-    # this function prepares everything for the generate library function
-    # it is very similar to the gather settings, how ever it stores the data instead of calling the Annotation Window class
-    # it moves the data onto the generateLib function, and then opens that window
-    # def prep_genlib(self):
-    #     # make sure the user actually inputs something
-    #     try:
-    #         inputstring = str(self.geneEntryField.toPlainText())
-    #         if (inputstring.startswith("Example Inputs:") or inputstring == ""):
-    #             show_message(
-    #                 fontSize=12,
-    #                 icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                 title="Error",
-    #                 message="No gene has been entered.  Please enter a gene.",
-    #                 button=QtWidgets.QMessageBox.StandardButton.Ok
-    #             )
-    #             return
-    #         else:
-    #             # standardize the input
-    #             inputstring = inputstring.lower()
-    #             found_matches_bool = True
-    #             # call the respective function
-    #             self.progressBar.setValue(10)
-    #             if self.radioButton_Gene.isChecked():
-    #                 if len(self.genlib_list) > 0:
-    #                     found_matches_bool = True
-    #                 else:
-    #                     found_matches_bool = False
-    #             elif self.radioButton_Position.isChecked() or self.radioButton_Sequence.isChecked():
-    #                 show_message(
-    #                     fontSize=12,
-    #                     icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                     title="Error",
-    #                     message="Generate Library can only work with feature searches.",
-    #                     button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                 )
-    #                 return
-    #             """
-    #             elif self.radioButton_Position.isChecked():
-    #                 pinput = inputstring.split(';')
-    #                 found_matches_bool = self.run_results("position", pinput,openAnnoWindow=False)
-    #             elif self.radioButton_Sequence.isChecked():
-    #                 sinput = inputstring
-    #                 found_matches_bool = self.run_results("sequence", sinput, openAnnoWindow=False)
-    #             """
-    #             # if matches are found
-    #             if found_matches_bool == True:
-    #                 # get the cspr file name
-    #                 cspr_file = self.organisms_to_files[self.orgChoice.currentText()][self.endoChoice.currentText()][0]
-    #                 if platform.system() == 'Windows':
-    #                     cspr_file = GlobalSettings.CSPR_DB + '\\' + cspr_file
-    #                 else:
-    #                     cspr_file = GlobalSettings.CSPR_DB + '/' + cspr_file
-    #                 kegg_non = 'non_kegg'
-    #                 # launch generateLib
-    #                 self.progressBar.setValue(100)
-    #                 # calculate the total number of matches found
-    #                 tempSum = len(self.genlib_list)
-    #                 # warn the user if the number is greater than 50
-    #                 if tempSum > 50:
-    #                     msgBox = QtWidgets.QMessageBox()
-    #                     msgBox.setStyleSheet("font: " + str(self.fontSize) + "pt 'Arial'")
-    #                     msgBox.setIcon(QtWidgets.QMessageBox.Icon.Question)
-    #                     msgBox.setWindowTitle("Many Matches Found")
-    #                     msgBox.setText("More than 50 matches have been found. Continuing could cause a slow down...\n\n Do you wish to continue?")
-    #                     msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Yes)
-    #                     msgBox.addButton(QtWidgets.QMessageBox.StandardButton.No)
-    #                     msgBox.exec()
-    #                     if (msgBox.result() == QtWidgets.QMessageBox.No):
-    #                         self.searches.clear()
-    #                         self.progressBar.setValue(0)
-    #                         return -2
-    #                 self.genLib.launch(self.genlib_list,cspr_file, kegg_non)
-    #             else:
-    #                 self.progressBar.setValue(0)
-    #     except Exception as e:
-    #         show_error("Error in prep_genlib() in main", e)
-    # # Function for collecting the settings from the input field and transferring them to run_results
-    # def gather_settings(self):
-    #     try:
-    #         ### If user searches multiple times for the same thing, this avoids re-searching the entire annotation file
-    #         check_org = self.orgChoice.currentText().lower()
-    #         check_endo = self.endoChoice.currentText().lower()
-    #         check_anno_name = self.annotation_files.currentText().lower()
-    #         check_input = str(self.geneEntryField.toPlainText()).lower()
-    #         if (check_input == self.inputstring and check_org == self.org and check_anno_name == self.anno_name and check_endo == self.endo_name):
-    #             same_search = True
-    #         else:
-    #             self.org = check_org
-    #             self.anno_name = check_anno_name
-    #             self.inputstring = check_input
-    #             self.endo_name = check_endo
-    #             same_search = False
-    #         # Error check: make sure the user actually inputs something
-    #         if (self.inputstring.startswith("Example Inputs:") or self.inputstring == ""):
-    #             show_message(
-    #                 fontSize=12,
-    #                 icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                 title="Error",
-    #                 message="No feature has been searched for. Please enter a search.",
-    #                 button=QtWidgets.QMessageBox.StandardButton.Ok
-    #             )
-    #             return
-    #         else:
-    #             ### Remove additional scoring columns if necessary
-    #             header = get_table_headers(self.Results.targetTable) # Returns headers of the target table in View Targets window
-    #             col_indices = [header.index(x) for x in GlobalSettings.algorithms if x in header] # Returns the index(es) of the alternative scoring column(s) in the target table of View Targets window
-    #             if len(col_indices) > 0: # If alternative scoring has been done
-    #                 for i in col_indices:
-    #                     self.Results.targetTable.removeColumn(i)
-    #             self.Results.targetTable.resizeColumnsToContents()
-    #             self.progressBar.setValue(10)
-    #             if self.radioButton_Gene.isChecked():
-    #                 ginput = [x.strip() for x in self.inputstring.split('\n')] # Split search based on newline character and remove deadspace
-    #                 self.run_results("feature", ginput, same_search)
-    #             elif self.radioButton_Position.isChecked():
-    #                 pinput = [x.strip() for x in self.inputstring.split('\n')] # Split search based on newline character and remove deadspace
-    #                 self.run_results("position", pinput, same_search)
-    #             elif self.radioButton_Sequence.isChecked():
-    #                 sinput = self.inputstring
-    #                 self.run_results("sequence", sinput, same_search)
-    #     except Exception as e:
-    #         show_error("Error in gather_settings() in main", e)
-    # # ---- Following functions are for running the auxillary algorithms and windows ---- #
-    # # this function is parses the annotation file given, and then goes through and goes onto results
-    # # it will call other versions of collect_table_data and fill_table that work with these file types
-    # # this function should work with the any type of annotation file, besides kegg.
-    # # this assumes that the parsers all store the data the same way, which gff and feature table do
-    # # please make sure the genbank parser stores the data in the same way
-    # # so far the gff files seems to all be different. Need to think about how we want to parse it
-    # def run_results_own_ncbi_file(self, inputstring, fileName, same_search, openAnnoWindow=True):
-    #     try:
-    #         self.set_progress(35)
-    #         self.results_list = self.annotation_parser.genbank_search(inputstring, same_search)
-    #         cspr_file = self.organisms_to_files[self.orgChoice.currentText()][self.endoChoice.currentText()][0]
-    #         cspr_file = os.path.join(GlobalSettings.CSPR_DB, cspr_file)
-    #         own_cspr_parser = CSPRparser(cspr_file)
-    #         own_cspr_parser.read_first_lines()
-    #         if len(own_cspr_parser.karystatsList) != self.annotation_parser.max_chrom:
-    #             show_message(
-    #                 fontSize=12,
-    #                 icon=QtWidgets.QMessageBox.Icon.Warning,
-    #                 title="Warning:",
-    #                 message="The number of chromosomes do not match. This could cause errors.",
-    #                 button=QtWidgets.QMessageBox.StandardButton.Ok
-    #             )
-    #         self.set_progress(60)
-    #         self.searches.clear()
-    #         self.set_progress(75)
-    #         if not self.results_list:
-    #             show_message(
-    #                 fontSize=12,
-    #                 icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                 title="No Matches Found",
-    #                 message="No matches found with that search, please try again.",
-    #                 button=QtWidgets.QMessageBox.StandardButton.Ok
-    #             )
-    #             self.set_progress(0)
-    #             return False if not openAnnoWindow else None
-    #         self.set_progress(80)
-    #         return self.Annotation_Window.fill_table_nonKegg(self, self.results_list) if openAnnoWindow else True
-    #     except Exception as e:
-    #         show_error(f"Error in run_results_own_ncbi_file() in main.", e)
-    # def set_progress(self, value):
-    #     self.progressBar.setValue(value)
-    # def run_results(self, inputtype, inputstring, same_search, openAnnoWindow=True):
-    #     try:
-    #         file_name = self.annotation_files.currentText()
-    #         for file in glob.glob(GlobalSettings.CSPR_DB + "/**/*.gb*", recursive=True):
-    #             if file_name in file:
-    #                 self.annotation_parser.annotationFileName = file
-    #                 break
-    #         self.Results.annotation_path = self.annotation_parser.annotationFileName
-    #         progvalue = 15
-    #         self.searches = {}
-    #         self.gene_list = {}
-    #         self.progressBar.setValue(progvalue)
-    #         try:
-    #             self.Results.endonucleaseBox.currentIndexChanged.disconnect()
-    #         except Exception as e:
-    #             pass
-    #         # set Results endo combo box
-    #         self.Results.endonucleaseBox.clear()
-    #         # set the results window endoChoice box menu
-    #         # set the mainWindow's endoChoice first, and then loop through and set the rest of them
-    #         self.Results.endonucleaseBox.addItem(self.endoChoice.currentText())
-    #         for item in self.organisms_to_endos[str(self.orgChoice.currentText())]:
-    #             if item != self.Results.endonucleaseBox.currentText():
-    #                 self.Results.endonucleaseBox.addItem(item)
-    #         self.Results.endonucleaseBox.currentIndexChanged.connect(self.Results.changeEndonuclease)
-    #         self.Results.get_endo_data()
-    # #        self.Results.change_start_end_button.setEnabled(False)
-    #         self.Results.displayGeneViewer.setChecked(0)
-    #         if inputtype == "feature":
-    #             fileType = self.annotation_parser.find_which_file_version()
-    #             # if the parser retuns the 'wrong file type' error
-    #             if fileType == -1:
-    #                 show_message(
-    #                     fontSize=12,
-    #                     icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                     title="Error",
-    #                     message="Feature search requires a GenBank formatted annotation file. Please select a file from the dropdown menu or search by position",
-    #                     button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                 )
-    #                 self.progressBar.setValue(0)
-    #                 return
-    #             # make sure an annotation file has been selected
-    #             if self.annotation_files.currentText() == "None":
-    #                 show_message(
-    #                     fontSize=12,
-    #                     icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                     title="Error",
-    #                     message="Search by feature requires a GenBank annotation file. Please select one from the dropdown menu or search by position.",
-    #                     button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                 )
-    #                 self.progressBar.setValue(0)
-    #                 return
-    #             # this now just goes onto the other version of run_results
-    #             myBool = self.run_results_own_ncbi_file(inputstring, self.annotation_files.currentText(), same_search, openAnnoWindow=openAnnoWindow)
-    #             if not openAnnoWindow:
-    #                 return myBool
-    #             else:
-    #                 self.progressBar.setValue(0)
-    #                 return
-    #         if inputtype == "position":
-    #             full_org = str(self.orgChoice.currentText())
-    #             self.checked_info.clear()
-    #             self.check_ntseq_info.clear()
-    #             for item in inputstring: # Loop through each search
-    #                 searchIndices = [x.strip() for x in item.split(',')] # Parse input query
-    #                 if len(searchIndices) != 3:
-    #                     show_message(
-    #                         fontSize=12,
-    #                         icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                         title="Error",
-    #                         message="There are 3 arguments required for this function: chromosome, start position, and end position.",
-    #                         button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                     )
-    #                     self.progressBar.setValue(0)
-    #                     return
-    #                 if not searchIndices[0].isdigit() or not searchIndices[1].isdigit() or not searchIndices[2].isdigit():
-    #                     show_message(
-    #                         fontSize=12,
-    #                         icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                         title="Error",
-    #                         message="The positions given must be integers. Please try again.",
-    #                         button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                     )
-    #                     self.progressBar.setValue(0)
-    #                     return
-    #                 elif int(searchIndices[1]) >= int(searchIndices[2]):
-    #                     show_message(
-    #                         fontSize=12,
-    #                         icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                         title="Error",
-    #                         message="The start index must be less than the end index.",
-    #                         button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                     )
-    #                     self.progressBar.setValue(0)
-    #                     return
-    #                 elif abs(int(searchIndices[2])-int(searchIndices[1])) > 50000:
-    #                     show_message(
-    #                         fontSize=12,
-    #                         icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                         title="Error",
-    #                         message="The search range must be less than 50,000 nt.",
-    #                         button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                     )
-    #                     self.progressBar.setValue(0)
-    #                     return
-    #                 elif int(searchIndices[0]) > self.annotation_parser.get_max_chrom():
-    #                     show_message(
-    #                         fontSize=12,
-    #                         icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                         title="Error",
-    #                         message="Chromosome %s does not exist in the selected annotation file." % searchIndices[0],
-    #                         button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                     )
-    #                     self.progressBar.setValue(0)
-    #                     return
-    #                 # append the data into the checked_info
-    #                 tempString = 'chrom: ' + str(searchIndices[0]) + ',start: ' + str(searchIndices[1]) + ',end: ' + str(searchIndices[2])
-    #                 self.checked_info[tempString] = (int(searchIndices[0]), int(searchIndices[1])-1, int(searchIndices[2]))
-    #             self.progressBar.setValue(50)
-    #             self.Results.transfer_data(full_org, self.organisms_to_files[full_org], [str(self.endoChoice.currentText())], os.getcwd(), self.checked_info, self.check_ntseq_info,inputtype)
-    #             self.Results.load_gene_viewer()
-    #             self.progressBar.setValue(100)
-    #             self.pushButton_ViewTargets.setEnabled(True)
-    #             self.GenerateLibrary.setEnabled(True)
-    #         if inputtype == "sequence":
-    #             fileType = self.annotation_parser.find_which_file_version()
-    #             if fileType == -1:
-    #                 show_message(
-    #                     fontSize=12,
-    #                     icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                     title="Error",
-    #                     message="Search by sequence requires a GenBank annotation file. Please select one from the dropdown menu or search by position.",
-    #                     button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                 )
-    #                 self.progressBar.setValue(0)
-    #                 return
-    #             if self.annotation_files.currentText() == "None":
-    #                 show_message(
-    #                     fontSize=12,
-    #                     icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                     title="Error",
-    #                     message="Search by sequence requires a GenBank annotation file. Please select one from the dropdown menu or search by position.",
-    #                     button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                 )
-    #                 self.progressBar.setValue(0)
-    #                 return
-    #             checkString = 'AGTCN'
-    #             full_org = str(self.orgChoice.currentText())
-    #             self.checked_info.clear()
-    #             self.progressBar.setValue(10)
-    #             inputstring = inputstring.replace('\n','').upper().strip()
-    #             for letter in inputstring:
-    #                 if letter not in checkString:
-    #                     show_message(
-    #                         fontSize=12,
-    #                         icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                         title="Error",
-    #                         message="The sequence must consist of A, G, T, C, or N. No other characters are allowed.",
-    #                         button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                     )
-    #                     self.progressBar.setValue(0)
-    #                     return
-    #             if len(inputstring) < 100:
-    #                 show_message(
-    #                     fontSize=12,
-    #                     icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                     title="Error",
-    #                     message="The sequence given is too small. At least 100 characters are required.",
-    #                     button=QtWidgets.QMessageBox.StandardButton.Ok
-    #                 )
-    #                 self.progressBar.setValue(0)
-    #                 return
-    #             if len(inputstring) > 10000:
-    #                 show_message(
-    #                     fontSize=12,
-    #                     icon=QtWidgets.QMessageBox.Icon.Question,
-    #                     title="Large Sequence Detected",
-    #                     message="The sequence given is too large one.\n\nPlease input a sequence less than 10kb in length.",
-    #                     button=QtWidgets.QMessageBox.StandardButton.Yes
-    #                 )
-    #                 self.progressBar.setValue(0)
-    #                 return
-    #             self.progressBar.setValue(30)
-    #             # Check the GBFF file for the sequence
-    #             my_check = self.annotation_parser.get_sequence_info(inputstring)
-    #             self.progressBar.setValue(55) # Update progress bar
-    #             if type(my_check) == bool:
-    #                 show_message(
-    #                     fontSize=12,
-    #                     icon=QtWidgets.QMessageBox.Icon.Question,
-    #                     title="Sequence Not Found",
-    #                     message="The sequence entered was not found.\n\nPlease input a sequence that is in the selected organism.",
-    #                     button=QtWidgets.QMessageBox.StandardButton.Yes
-    #                 )
-    #                 self.progressBar.setValue(0)
-    #                 return
-    #             else:
-    #                 tempString = 'chrom: ' + str(my_check[0]) + ',start: ' + str(my_check[1]) + ',end: ' + str(my_check[2])
-    #                 self.checked_info[tempString] = (int(my_check[0]), int(my_check[1])-1, int(my_check[2]))
-    #             self.progressBar.setValue(75)
-    #             self.Results.transfer_data(full_org, self.organisms_to_files[full_org], [str(self.endoChoice.currentText())], os.getcwd(), self.checked_info, self.check_ntseq_info, inputtype)
-    #             self.Results.load_gene_viewer()
-    #             self.progressBar.setValue(100)
-    #             self.pushButton_ViewTargets.setEnabled(True)
-    #             self.GenerateLibrary.setEnabled(True)
-    #     except Exception as e:
-    #         show_error("Error in run_results() in main", e)
-    # def handle_feature_search(self, input_string, open_anno_window):
-    #     file_type = self.annotation_parser.find_which_file_version()
-    #     if file_type == -1 or self.annotation_files.currentText() == "None":
-    #         self.show_error_message("Feature search requires a GenBank formatted annotation file.")
-    #         return False
-    #     return self.run_results_own_ncbi_file(input_string, self.annotation_files.currentText(), same_search, open_anno_window)
-    # def launch_newGenome(self):
-    #     try:
-    #         # Update endo list
-    #         self.get_new_genome().fillEndo()
-    #         if self.get_new_genome().first_show:
-    #             center_ui(self.get_new_genome())
-    #             self.get_new_genome().first_show = False
-    #         self.hide()
-    #         self.get_new_genome().show()
-    #     except Exception as e:
-    #         show_error("Error in launch_newGenome() in main", e)
-    # def launch_newEndonuclease(self):
-    #     try:
-    #         center_ui(self.newEndonuclease)
-    #         self.newEndonuclease.show()
-    #         self.newEndonuclease.activateWindow()
-    #     except Exception as e:
-    #         show_error("Error in launch_newEndonuclease() in main", e)
-    # #launch genome browser tool
-    # def launch_newGenomeBrowser(self):
-    #     try:
-    #         self.genomebrowser.createGraph(self)
-    #     except Exception as e:
-    #         show_error("Error in launch_newGenomeBrowser() in main", e)
-    # def launch_ncbi(self):
-    #     try:
-    #         show_message(
-    #             fontSize=12,
-    #             icon=QtWidgets.QMessageBox.Icon.Information,
-    #             title="Note:",
-    #             message="NCBI Annotation Guidelines:\n\nDownload annotation files of the exact species and strain used in Analyze New Genome.\n\nMismatched annotation files will inhibit downstream analyses.",
-    #             button=QtWidgets.QMessageBox.StandardButton.Ok
-    #         )
-    #         if self.ncbi.first_show:
-    #             self.ncbi.first_show = False
-    #             center_ui(self.ncbi)
-    #         self.ncbi.show()
-    #         self.ncbi.activateWindow()
-    #     except Exception as e:
-    #         show_error("launch_ncbi() in main", e)
-    # # this function does the same stuff that the other collect_table_data does, but works with the other types of files
-    # def collect_table_data_nonkegg(self):
-    #     try:
-    #         # start out the same as the other collect_table_data
-    #         self.checked_info.clear()
-    #         self.genlib_list.clear()
-    #         self.check_ntseq_info.clear()
-    #         full_org = str(self.orgChoice.currentText())
-    #         holder = ()
-    #         selected_indices = []
-    #         selected_rows = self.Annotation_Window.tableWidget.selectionModel().selectedRows()
-    #         for ind in sorted(selected_rows):
-    #             selected_indices.append(ind.row())
-    #         for item in self.checkBoxes:
-    #             feature = item[1]
-    #             # If inidices of checkBoxes list and selected rows in table match...
-    #             if item[2] in selected_indices:
-    #                 holder = (item[0],int(feature.location.start),int(feature.location.end)) # Tuple order: Feature chromosome/scaffold number, feature start, feature end
-    #                 ### If locus tag available, combine with gene name to create dict key
-    #                 if 'locus_tag' in feature.qualifiers:
-    #                     tag = feature.qualifiers['locus_tag'][0]
-    #                     key = tag + ": " + get_name(feature)
-    #                 else:
-    #                     key = get_name(feature)
-    #                 self.checked_info[key] = holder
-    #                 self.genlib_list.append((item[0],feature)) # Tuple order: Feature chromosome/scaffold number, SeqFeature object
-    #             else:
-    #                 # If item was not selected in the table, go to the next item
-    #                 continue
-    #         # now call transfer data
-    #         self.progressBar.setValue(95)
-    #         self.Results.transfer_data(full_org, self.organisms_to_files[full_org], [str(self.endoChoice.currentText())], os.getcwd(),
-    #                                    self.checked_info, self.check_ntseq_info,inputtype="feature")
-    #         self.Results.load_gene_viewer()
-    #         self.progressBar.setValue(100)
-    #         self.pushButton_ViewTargets.setEnabled(True)
-    #         self.GenerateLibrary.setEnabled(True)
-    #     except Exception as e:
-    #         show_error("Error in collect_table_data_nonkegg() in main", e)
-    # def separate_line(self, input_string):
-    #     try:
-    #         export_array = []
-    #         while True:
-    #             index = input_string.find('\n')
-    #             if index == -1:
-    #                 if len(input_string) == 0:
-    #                     return export_array
-    #                 else:
-    #                     export_array.append(input_string)
-    #                     return export_array
-    #             export_array.append(input_string[:index])
-    #             input_string = input_string[index + 1:]
-    #     except Exception as e:
-    #         show_error("Error in seperate_line() in main", e)
-    # def removeWhiteSpace(self, strng):
-    #     try:
-    #         while True:
-    #             if len(strng) == 0 or (strng[0] != " " and strng[0] != "\n"):
-    #                 break
-    #             strng = strng[1:]
-    #         while True:
-    #             if len(strng) == 0 or (strng[len(strng) - 1] != " " and strng[0] != "\n"):
-    #                 return strng
-    #             strng = strng[:len(strng) - 1]
-    #     except Exception as e:
-    #         show_error("Error in removeWhiteSpace() in main", e)
-    # # Function to enable and disable the Annotation function if searching by position or sequence
-    # def toggle_annotation(self):
-    #     try:
-    #         if self.radioButton_Gene.isChecked():
-    #             self.Step2.setEnabled(True)
-    #         else:
-    #             self.Step2.setEnabled(True)
-    #     except Exception as e:
-    #         show_error("Error in toggle_annotation() in main", e)
-    # def fill_annotation_dropdown(self):
-    #     try:
-    #         #recursive search for all GenBank files in casper db folder
-    #         self.annotation_files.clear()
-    #         annotation_files = glob.glob(GlobalSettings.CSPR_DB + "/**/*.gb*", recursive=True)
-    #         if platform.system() == "Windows":
-    #             for i in range(len(annotation_files)):
-    #                 annotation_files[i] = annotation_files[i].replace("/","\\")
-    #                 annotation_files[i] = annotation_files[i][annotation_files[i].rfind("\\") + 1:]
-    #         else:
-    #             for i in range(len(annotation_files)):
-    #                 annotation_files[i] = annotation_files[i].replace("\\","/")
-    #                 annotation_files[i] = annotation_files[i][annotation_files[i].rfind("/") + 1:]
-    #         annotation_files.sort(key=str.lower)
-    #         self.annotation_files.addItems(annotation_files)
-    #         self.annotation_files.addItems(["None"])
-    #     except Exception as e:
-    #         show_error("Error in fill_annotation_dropdown() in main", e)
-    # def make_dictonary(self):
-    #     try:
-    #         url = "https://www.genome.jp/dbget-bin/get_linkdb?-t+genes+gn:" + self.TNumbers[
-    #             self.Annotations_Organism.currentText()]
-    #         source_code = requests.get(url, verify=False)
-    #         plain_text = source_code.text
-    #         buf = io.StringIO(plain_text)
-    #         while True:
-    #             line = buf.readline()
-    #             if line[0] == "-":
-    #                 break
-    #         while True:
-    #             line = buf.readline()
-    #             if line[1] != "a":
-    #                 return
-    #             line = line[line.find(">") + 1:]
-    #             seq = line[line.find(":") + 1:line.find("<")]
-    #             line = line[line.find(">") + 1:]
-    #             i = 0
-    #             while True:
-    #                 if line[i] == " ":
-    #                     i = i + 1
-    #                 else:
-    #                     break
-    #             key = line[i:line.find("\n") - 1]
-    #             if key in self.gene_list:
-    #                 if seq not in self.gene_list[key]:
-    #                     self.gene_list[key].append(seq)
-    #             else:
-    #                 self.gene_list[key] = [seq]
-    #             z = 5
-    #     except Exception as e:
-    #         show_error("Error in make_dictionary() in main", e)
-    # def organism_finder(self, long_str):
-    #     try:
-    #         semi = long_str.find(";")
-    #         index = 1
-    #         while True:
-    #             if long_str[semi - index] == " ":
-    #                 break
-    #             index = index + 1
-    #         return long_str[:semi - index]
-    #     except Exception as e:
-    #         show_error("Error in organism_finder() in main", e)
-    # # This method is for testing the execution of a button call to make sure the button is linked properly
-    # def testexe(self):
-    #     try:
-    #         msgBox = QtWidgets.QMessageBox()
-    #         msgBox.setStyleSheet("font: " + str(self.fontSize) + "pt 'Arial'")
-    #         msgBox.setIcon(QtWidgets.QMessageBox.Icon.Question)
-    #         msgBox.setWindowTitle("Extract!")
-    #         msgBox.setText(
-    #             "Are you sure you want to quit?")
-    #         msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Yes)
-    #         msgBox.addButton(QtWidgets.QMessageBox.StandardButton.No)
-    #         msgBox.exec()
-    #         if msgBox.result() == QtWidgets.QMessageBox.Yes:
-    #             # print(self.orgChoice.currentText())
-    #             sys.exit()
-    #         else:
-    #             pass
-    #     except Exception as e:
-    #         show_error("Error in testexe() in main", e)
-    # def getData(self):
-    #     try:
-    #         try:
-    #             self.orgChoice.currentIndexChanged.disconnect()
-    #         except Exception as e:
-    #              pass
-    #         self.orgChoice.clear()
-    #         self.endoChoice.clear()
-    #         mypath = os.getcwd()
-    #         found = False
-    #         self.dbpath = mypath
-    #         onlyfiles = [str(f) for f in os.listdir(mypath) if os.path.isfile(os.path.join(mypath, f))]
-    #         onlyfiles.sort(key=str.lower)
-    #         self.organisms_to_files = {}
-    #         self.organisms_to_endos = {}
-    #         first = True
-    #         for file in onlyfiles:
-    #             if file.find('.cspr') != -1:
-    #                 if first == True:
-    #                     first = False
-    #                 found = True
-    #                 newname = file[0:-4]
-    #                 endo = newname[newname.rfind("_")+1:-1]
-    #                 hold = open(file, 'r')
-    #                 buf = (hold.readline())
-    #                 buf = str(buf)
-    #                 buf = buf.strip()
-    #                 species = buf.replace("GENOME: ",'')
-    #                 if species in self.organisms_to_files:
-    #                     self.organisms_to_files[species][endo] = [file, file.replace(".cspr", "_repeats.db")]
-    #                 else:
-    #                     self.organisms_to_files[species] = {}
-    #                     self.organisms_to_files[species][endo] = [file, file.replace(".cspr", "_repeats.db")]
-    #                 if species in self.organisms_to_endos:
-    #                     self.organisms_to_endos[species].append(endo)
-    #                 else:
-    #                     self.organisms_to_endos[species] = [endo]
-    #                     if self.orgChoice.findText(species) == -1:
-    #                         self.orgChoice.addItem(species)
-    #         if found == False:
-    #             return False
-    #         self.endoChoice.clear()
-    #         self.endoChoice.addItems(self.organisms_to_endos[str(self.orgChoice.currentText())])
-    #         self.orgChoice.currentIndexChanged.connect(self.changeEndos)
-    #     except Exception as e:
-    #         show_error("Error in getData() in main.", e)
-    # def changeEndos(self):
-    #     try:
-    #         if self.orgChoice.currentText() != "Custom Input Sequences":
-    #             self.Step2.setEnabled(True)
-    #             self.endoChoice.setEnabled(True)
-    #             self.radioButton_Gene.show()
-    #             self.radioButton_Position.show()
-    #             self.endoChoice.clear()
-    #             self.endoChoice.addItems(self.organisms_to_endos[str(self.orgChoice.currentText())])
-    #         else:
-    #             self.Step2.setEnabled(False)
-    #             self.endoChoice.clear()
-    #             self.endoChoice.setEnabled(False)
-    #             self.radioButton_Gene.hide()
-    #             self.radioButton_Position.hide()
-    #     except Exception as e:
-    #         show_error("Error in changeEndos() in main", e)
-    # def change_directory(self):
-    #     try:
-    #         mydir = QtWidgets.QFileDialog.getExistingDirectory(
-    #             None, "Open a folder...", self.dbpath, QtWidgets.QFileDialog.Option.ShowDirsOnly)
-    #         if not os.path.isdir(mydir):
-    #             show_message(
-    #                 fontSize=12,
-    #                 icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                 title="Not a directory",
-    #                 message="The directory you selected does not exist."
-    #             )
-    #             return
-    #         if not any(file.endswith(".cspr") for file in os.listdir(mydir)):
-    #             show_message(
-    #                 fontSize=12,
-    #                 icon=QtWidgets.QMessageBox.Icon.Critical,
-    #                 title="Directory is invalid!",
-    #                 message="You must select a directory with CSPR Files!"
-    #             )
-    #             return
-    #         os.chdir(mydir)
-    #         mydir = mydir.replace("/", "\\") if platform.system() == "Windows" else mydir
-    #         GlobalSettings.CSPR_DB = mydir
-    #         GlobalSettings.MTWin.directory = mydir
-    #         GlobalSettings.MTWin.get_data()
-    #         GlobalSettings.pop_Analysis.get_data()
-    #         self.getData()
-    #         self.fill_annotation_dropdown()
-    #     except Exception as e:
-    #         show_error("Error in change_directory() in main.", e)
-    # def changeto_multitargeting(self):
-    #     try:
-    #         os.chdir(os.getcwd())
-    #         if GlobalSettings.MTWin.first_show == True:
-    #             GlobalSettings.MTWin.show()
-    #             GlobalSettings.MTWin.first_show = False
-    #         else:
-    #             GlobalSettings.MTWin.show()
-    #             GlobalSettings.mainWindow.hide()
-    #     except Exception as e:
-    #         show_error("Error in changeto_multitargeting() in main.", e)
-    # #change to population analysis window
-    # def changeto_population_Analysis(self):
-    #     try:
-    #         GlobalSettings.pop_Analysis.launch()
-    #         if GlobalSettings.pop_Analysis.first_show == True:
-    #             center_ui(GlobalSettings.pop_Analysis)
-    #             GlobalSettings.pop_Analysis.first_show = False
-    #         GlobalSettings.pop_Analysis.show()
-    #         GlobalSettings.mainWindow.hide()
-    #     except Exception as e:
-    #         show_error("Error in changeto_population_Analysis() in main.", e)
-    # def annotation_information(self):
-    #     try:
-    #         show_message(
-    #             fontSize=12,
-    #             icon=QtWidgets.QMessageBox.Icon.Critical,
-    #             title="Annotation Information",
-    #             message="Annotation files are used for searching for spacers on a gene/locus basis and can be selected here using either " \
-    #                     "NCBI databases or a local file."
-    #         )
-    #     except Exception as e:
-    #         show_error("Error in annotation_information() in main.", e)
-    # @QtCore.pyqtSlot()
-    # def view_results(self):
-    #     try:
-    #         #center results window on current screen
-    #         if self.Results.first_show == True:
-    #             self.Results.first_show = False
-    #             self.Results.centerUI()
-    #         self.Results.show()
-    #         self.hide()
-    #     except Exception as e:
-    #         show_error("Error in view_results() in main", e)
-    # def closeFunction(self):
-    #     try:
-    #         # Attempt to close the NCBI window if it exists
-    #         try:
-    #             self.ncbi.close()
-    #         except AttributeError:
-    #             print("No NCBI window to close.")
-    #         self.myClosingWindow.get_files()
-    #         center_ui(self.myClosingWindow)
-    #         self.myClosingWindow.show()
-    #     except Exception as e:
-    #         show_error("Error in closeFunction() in main", e)
-    # def close_app(self):
-    #     try:
-    #         # Attempt to close the NCBI window if it exists
-    #         try:
-    #             self.ncbi.close()
-    #         except Exception as e:
-    #             print("No NCBI window to close.")
-    #         self.closeFunction()
-    #         self.close()
-    #     except Exception as e:
-    #         show_error("Error in close_app() in main", e)
-    # def load_dropdown_data(self):
-    #     """Fill in organism/endo/annotation dropdown information."""
-    #     try:
-    #         self.getData()
-    #         self.fill_annotation_dropdown()
-    #         # self.logger.debug("Successfully loaded organism/endo/annotation drop down information in Main.")
-    #     except Exception as e:
-    #         show_error("Error in load_dropdown_data() in Main", e)
-    # # Call methods for other windows if needed
-    # # self.load_mt_data()
-    # # self.load_pop_analysis_data()

src/views/FindTargetsView.py CHANGED Viewed

@@ -1,7 +1,7 @@
 from PyQt6 import QtWidgets
 from PyQt6.QtWidgets import QWidget, QVBoxLayout, QTableWidget, QTableWidgetItem, QPushButton, QHBoxLayout, QLabel
 from PyQt6 import uic
-from PyQt6.QtCore import Qt
 class FindTargetsView(QtWidgets.QMainWindow):
     def __init__(self, global_settings):
@@ -14,6 +14,11 @@ class FindTargetsView(QtWidgets.QMainWindow):
         self.results_table = self.findChild(QTableWidget, 'tblTargets')
         self.results_table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
         # Set up the table columns
         self.results_table.setColumnCount(7)
         self.results_table.setHorizontalHeaderLabels([
@@ -23,50 +28,68 @@ class FindTargetsView(QtWidgets.QMainWindow):
         self.push_button_view_targets = self.findChild(QPushButton, 'pbtnViewTargets')
-        # Add buttons
-        # button_layout = QHBoxLayout()
-        # self.export_button = QPushButton("Export")
-        # self.view_targets_button = QPushButton("View Targets")
-        # self.generate_library_button = QPushButton("Generate Library")
-        # button_layout.addWidget(self.export_button)
-        # button_layout.addWidget(self.view_targets_button)
-        # button_layout.addWidget(self.generate_library_button)
-        # Add result count label
-        # self.result_count_label = QLabel("Results: 0")
-        # main_layout = QVBoxLayout(self)
-        # main_layout.addWidget(self.result_count_label)
-        # main_layout.addWidget(self.results_table)
-        # main_layout.addLayout(button_layout)
     def display_results(self, results):
         self.results_table.setRowCount(len(results))
         for row, result in enumerate(results):
-            self.results_table.setItem(row, 0, QTableWidgetItem(result['feature_type']))
-            self.results_table.setItem(row, 1, QTableWidgetItem(str(result['chromosome'])))
-            self.results_table.setItem(row, 2, QTableWidgetItem(result['feature_id']))
-            self.results_table.setItem(row, 3, QTableWidgetItem(result['feature_name']))
-            self.results_table.setItem(row, 4, QTableWidgetItem(result['feature_description']))
-            self.results_table.setItem(row, 5, QTableWidgetItem(result['location']))
-            self.results_table.setItem(row, 6, QTableWidgetItem(result['strand']))
         self.results_table.resizeColumnsToContents()
-        # self.result_count_label.setText(f"Results: {len(results)}")
     def get_selected_targets(self):
         selected_rows = set(index.row() for index in self.results_table.selectedIndexes())
         selected_targets = []
         for row in selected_rows:
             target = {
-                'feature_type': self.results_table.item(row, 0).text(),
-                'chromosome': self.results_table.item(row, 1).text(),
-                'feature_id': self.results_table.item(row, 2).text(),
-                'feature_name': self.results_table.item(row, 3).text(),
-                'feature_description': self.results_table.item(row, 4).text(),
-                'location': self.results_table.item(row, 5).text(),
-                'strand': self.results_table.item(row, 6).text()
             }
             selected_targets.append(target)
         return selected_targets

 from PyQt6 import QtWidgets
 from PyQt6.QtWidgets import QWidget, QVBoxLayout, QTableWidget, QTableWidgetItem, QPushButton, QHBoxLayout, QLabel
 from PyQt6 import uic
+from PyQt6.QtCore import Qt, QTimer
 class FindTargetsView(QtWidgets.QMainWindow):
     def __init__(self, global_settings):
         self.results_table = self.findChild(QTableWidget, 'tblTargets')
         self.results_table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
+        # Optimize table performance
+        self.results_table.setUpdatesEnabled(False)  # Disable updates during setup
+        self.results_table.setSortingEnabled(False)  # Disable sorting during setup
+        self.results_table.horizontalHeader().setStretchLastSection(True)
         # Set up the table columns
         self.results_table.setColumnCount(7)
         self.results_table.setHorizontalHeaderLabels([
         self.push_button_view_targets = self.findChild(QPushButton, 'pbtnViewTargets')
+        # Pre-allocate items for better performance
+        self._cached_items = {}
+    def _get_table_item(self, text):
+        """Cache and reuse QTableWidgetItems for better performance"""
+        if text not in self._cached_items:
+            item = QTableWidgetItem(str(text))
+            item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)  # Make item read-only
+            self._cached_items[text] = item
+        return self._cached_items[text].clone()
     def display_results(self, results):
+        # Disable updates for bulk operations
+        self.results_table.setUpdatesEnabled(False)
+        self.results_table.setSortingEnabled(False)
+        # Set row count once
         self.results_table.setRowCount(len(results))
+        # Batch insert items
         for row, result in enumerate(results):
+            self.results_table.setItem(row, 0, self._get_table_item(result['feature_type']))
+            self.results_table.setItem(row, 1, self._get_table_item(str(result['chromosome'])))
+            self.results_table.setItem(row, 2, self._get_table_item(result['feature_id']))
+            self.results_table.setItem(row, 3, self._get_table_item(result['feature_name']))
+            self.results_table.setItem(row, 4, self._get_table_item(result['feature_description']))
+            self.results_table.setItem(row, 5, self._get_table_item(result['location']))
+            self.results_table.setItem(row, 6, self._get_table_item(result['strand']))
+        # Re-enable updates and adjust columns
+        QTimer.singleShot(0, self._finish_table_update)
+    def _finish_table_update(self):
+        """Complete table update in the next event loop iteration"""
         self.results_table.resizeColumnsToContents()
+        self.results_table.setUpdatesEnabled(True)
+        self.results_table.setSortingEnabled(True)
     def get_selected_targets(self):
         selected_rows = set(index.row() for index in self.results_table.selectedIndexes())
         selected_targets = []
+        # Get column indices once
+        columns = {
+            'feature_type': 0,
+            'chromosome': 1,
+            'feature_id': 2,
+            'feature_name': 3,
+            'feature_description': 4,
+            'location': 5,
+            'strand': 6
+        }
         for row in selected_rows:
             target = {
+                'feature_type': self.results_table.item(row, columns['feature_type']).text(),
+                'chromosome': self.results_table.item(row, columns['chromosome']).text(),
+                'feature_id': self.results_table.item(row, columns['feature_id']).text(),
+                'feature_name': self.results_table.item(row, columns['feature_name']).text(),
+                'feature_description': self.results_table.item(row, columns['feature_description']).text(),
+                'location': self.results_table.item(row, columns['location']).text(),
+                'strand': self.results_table.item(row, columns['strand']).text()
             }
             selected_targets.append(target)
         return selected_targets

src/views/HomeWindowView.py CHANGED Viewed

@@ -124,3 +124,6 @@ class HomeWindowView(QWidget):
             return "sequence"
         else:
             return "feature"  # Default to feature if somehow none are selected

             return "sequence"
         else:
             return "feature"  # Default to feature if somehow none are selected
+    def get_annotation_file(self) -> str:
+        return self.combo_box_local_annotation_files.currentText()

src/views/MainWindowView.py CHANGED Viewed

@@ -13,53 +13,149 @@ from functools import partial
 import qdarktheme
 class CloseableTabWidget(QTabWidget):
-    # Define a new signal that emits the closed widget
     tab_closed = pyqtSignal(QWidget)
     def __init__(self, parent=None):
         super().__init__(parent)
         self.setTabsClosable(False)
         self.tabCloseRequested.connect(self.closeTab)
     def closeTab(self, index):
-        if self.count() > 1 and index != 0:
-            widget = self.widget(index)
-            self.removeTab(index)
-            widget.deleteLater()
-            # Emit the signal with the closed widget
-            self.tab_closed.emit(widget)
     def addTab(self, widget, label):
-        index = super().addTab(widget, label)
-        print(f"Adding tab: {label}, Index: {index}")
-        if index != 0:
-            # Create a close button
-            close_button = QToolButton(self.tabBar())
-            close_icon = self.style().standardIcon(QtWidgets.QStyle.StandardPixmap.SP_TitleBarCloseButton)
-            close_button.setIcon(close_icon)
-            close_button.setIconSize(QSize(16, 16))
-            close_button.setAutoRaise(True)
-            # Apply updated stylesheet with adjusted negative margin and border-radius
-            close_button.setStyleSheet("""
-                QToolButton {
-                    border: none;
-                    padding: 0px;
-                }
-                QToolButton:hover {
-                    background: #c42b1c;
                 }
-            """)
-            close_button.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-            close_button.setFixedSize(18, 18)  # Fixed size larger than icon to allow padding
-            # Connect the close button's clicked signal using partial to pass the index
-            close_button.clicked.connect(partial(self.closeTab, index))
-            # Add the close button to the tab
-            self.tabBar().setTabButton(index, QTabBar.ButtonPosition.RightSide, close_button)
-        return index
 class MainWindowView(QMainWindow):
@@ -71,13 +167,38 @@ class MainWindowView(QMainWindow):
         self.oldPos = None
     def _init_ui(self) -> None:
         try:
-            self._load_ui_file
             self._load_ui_file()
             self._init_window_properties()
             self._init_ui_elements()
             self._scale_ui()
-            self.logger.debug(f"After _scale_ui call in _init_ui. Window size: {self.size()}")
         except Exception as e:
             self._handle_init_error(e)
@@ -89,11 +210,16 @@ class MainWindowView(QMainWindow):
         """
         Creates a frameless, translucent window without a toolbar.
         """
         self.setWindowFlags(Qt.WindowType.FramelessWindowHint)
         self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
         toolbars = self.findChildren(QtWidgets.QToolBar)
         for toolbar in toolbars:
             toolbar.hide()
     def _init_ui_elements(self) -> None:
         # Initialize menu bar and custom title bar
@@ -260,20 +386,40 @@ class MainWindowView(QMainWindow):
     #     self.tab_widget.setCurrentIndex(tab_index)
-    def _scale_ui(self) -> None:
-        initial_size = self.size()
-        self.logger.debug(f"Initial window size before scale_ui: {initial_size}")
-        scale_ui(self, custom_scale_width=1000, custom_scale_height=350)
-        final_size = self.size()
-        self.logger.debug(f"Final window size after scale_ui: {final_size}")
-        if initial_size == final_size:
-            self.logger.warning("Window size did not change after scale_ui call")
-        else:
-            self.logger.info(f"Window size changed from {initial_size} to {final_size}")
-        self.resize(575, 400)
-        self.logger.debug(f"Forced resize to 1000x350. New size: {self.size()}")
     def _handle_init_error(self, e: Exception) -> None:
         error_msg = f"Error initializing MainWindowView: {str(e)}"
@@ -395,3 +541,14 @@ class MainWindowView(QMainWindow):
                 background: {theme['tab_hover_bg_color']};
             }}
         """)

 import qdarktheme
 class CloseableTabWidget(QTabWidget):
     tab_closed = pyqtSignal(QWidget)
     def __init__(self, parent=None):
         super().__init__(parent)
         self.setTabsClosable(False)
         self.tabCloseRequested.connect(self.closeTab)
+        self._tabs = {}  # Dictionary to keep track of tab widgets
+        self.tabBar().tabMoved.connect(self._handle_tab_moved)
     def closeTab(self, index):
+        try:
+            if self.count() > 1 and index != 0:
+                widget = self.widget(index)
+                if widget:
+                    # Get tab text before removal
+                    tab_text = self.tabText(index)
+                    # Clean up the controller if it exists
+                    controller = getattr(widget, 'controller', None)
+                    if controller and hasattr(controller, 'model') and hasattr(controller.model, 'cleanup'):
+                        controller.model.cleanup()
+                    # Remove from tracking dictionary
+                    if tab_text in self._tabs:
+                        del self._tabs[tab_text]
+                    # Remove the tab
+                    self.removeTab(index)
+                    # Emit signal before deletion
+                    self.tab_closed.emit(widget)
+                    # Schedule widget for deletion
+                    widget.deleteLater()
+                    # Update all remaining tabs
+                    self._update_all_tabs()
+        except Exception as e:
+            print(f"Error closing tab: {e}")
     def addTab(self, widget, label):
+        try:
+            if widget and label:
+                # Store widget reference with unique identifier
+                tab_id = f"{label}_{id(widget)}"
+                self._tabs[tab_id] = {
+                    'widget': widget,
+                    'label': label,
+                    'close_button': None
                 }
+                # Add the tab
+                index = super().addTab(widget, label)
+                if index != 0:
+                    # Create and setup close button
+                    close_button = self._create_close_button(index, label)
+                    self._tabs[tab_id]['close_button'] = close_button
+                    self.tabBar().setTabButton(index, QTabBar.ButtonPosition.RightSide, close_button)
+                return index
+        except Exception as e:
+            print(f"Error adding tab: {e}")
+            return -1
+    def _create_close_button(self, index, label):
+        """Create a new close button for a tab"""
+        close_button = QToolButton(self.tabBar())
+        close_button.setObjectName(f"close_button_{label}")
+        close_icon = self.style().standardIcon(QtWidgets.QStyle.StandardPixmap.SP_TitleBarCloseButton)
+        close_button.setIcon(close_icon)
+        close_button.setIconSize(QSize(16, 16))
+        close_button.setAutoRaise(True)
+        close_button.setStyleSheet("""
+            QToolButton {
+                border: none;
+                padding: 0px;
+            }
+            QToolButton:hover {
+                background: #c42b1c;
+            }
+        """)
+        close_button.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+        close_button.setFixedSize(18, 18)
+        close_button.clicked.connect(lambda checked, idx=index: self.safely_close_tab(idx))
+        return close_button
+    def safely_close_tab(self, index):
+        """Safely handle tab closure with error checking"""
+        try:
+            if 0 <= index < self.count():
+                current_widget = self.widget(index)
+                if current_widget and index != 0:
+                    self.closeTab(index)
+        except Exception as e:
+            print(f"Error in safely_close_tab: {e}")
+    def _handle_tab_moved(self, from_index: int, to_index: int):
+        """Handle tab movement and update close buttons"""
+        try:
+            self._update_all_tabs()
+        except Exception as e:
+            print(f"Error handling tab movement: {e}")
+    def _update_all_tabs(self):
+        """Update all tabs and their close buttons"""
+        try:
+            for i in range(1, self.count()):  # Skip index 0 (home tab)
+                widget = self.widget(i)
+                if widget:
+                    label = self.tabText(i)
+                    tab_id = f"{label}_{id(widget)}"
+                    # Create new close button if needed
+                    if tab_id not in self._tabs or not self._tabs[tab_id].get('close_button'):
+                        close_button = self._create_close_button(i, label)
+                        self._tabs[tab_id] = {
+                            'widget': widget,
+                            'label': label,
+                            'close_button': close_button
+                        }
+                        self.tabBar().setTabButton(i, QTabBar.ButtonPosition.RightSide, close_button)
+                    else:
+                        # Update existing close button's click connection
+                        close_button = self._tabs[tab_id]['close_button']
+                        close_button.clicked.disconnect()
+                        close_button.clicked.connect(lambda checked, idx=i: self.safely_close_tab(idx))
+        except Exception as e:
+            print(f"Error updating tabs: {e}")
+    def moveTab(self, from_index, to_index):
+        """Override moveTab to safely handle tab movement"""
+        try:
+            if (0 <= from_index < self.count() and
+                0 <= to_index < self.count() and
+                from_index != 0 and
+                to_index != 0):
+                super().moveTab(from_index, to_index)
+                self._update_all_tabs()
+        except Exception as e:
+            print(f"Error moving tab: {e}")
 class MainWindowView(QMainWindow):
         self.oldPos = None
     def _init_ui(self) -> None:
+        # Hide the window and disable updates during initialization
+        self.hide()
+        self.setUpdatesEnabled(False)
         try:
+            # Calculate center position first
+            screen = QtGui.QGuiApplication.primaryScreen()
+            screen_geometry = screen.geometry()
+            centerPoint = screen_geometry.center()
+            # Load and initialize UI
             self._load_ui_file()
             self._init_window_properties()
             self._init_ui_elements()
+            self.apply_theme()
             self._scale_ui()
+            # Get final size
+            final_size = self.size()
+            # Calculate position only once
+            x = centerPoint.x() - (final_size.width() // 2)
+            y = centerPoint.y() - (final_size.height() // 2)
+            # Set position and size in a single operation
+            self.setGeometry(x, y, final_size.width(), final_size.height())
+            # Re-enable updates and show window
+            self.setUpdatesEnabled(True)
+            self.show()
+            self.repaint()  # Force immediate repaint
+            self.logger.debug(f"Window initialized at position ({x}, {y}) with size {final_size}")
         except Exception as e:
             self._handle_init_error(e)
         """
         Creates a frameless, translucent window without a toolbar.
         """
+        # Set window flags before other properties
         self.setWindowFlags(Qt.WindowType.FramelessWindowHint)
         self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        self.setAttribute(Qt.WidgetAttribute.WA_NoSystemBackground)
+        # Hide toolbars
         toolbars = self.findChildren(QtWidgets.QToolBar)
         for toolbar in toolbars:
             toolbar.hide()
+        # Ensure window starts hidden
+        self.setVisible(False)
     def _init_ui_elements(self) -> None:
         # Initialize menu bar and custom title bar
     #     self.tab_widget.setCurrentIndex(tab_index)
+    def _scale_ui(self):
+        """Modified scale_ui to only handle sizing, not positioning"""
+        try:
+            screen = QtGui.QGuiApplication.primaryScreen()
+            screen_geometry = screen.geometry()
+            width = screen_geometry.width()
+            height = screen_geometry.height()
+            # Font scaling
+            self.centralWidget().setStyleSheet(f"font: 12pt 'Arial';")
+            if hasattr(self, 'title'):
+                scaled_title_font_size = int(30 * (width / 1920))
+                self.title.setStyleSheet(f"font: bold {scaled_title_font_size}pt 'Arial';")
+            # Calculate size only
+            scaledWidth = int((width * 575) / 1920)
+            scaledHeight = int((height * 400) / 1080)
+            # Ensure minimum size
+            self.adjustSize()
+            currentWidth = self.size().width()
+            currentHeight = self.size().height()
+            if scaledHeight < currentHeight:
+                scaledHeight = currentHeight
+            if scaledWidth < currentWidth:
+                scaledWidth = currentWidth
+            # Only resize, don't reposition
+            self.resize(scaledWidth, scaledHeight)
+        except Exception as e:
+            self.logger.error(f"Error in _scale_ui: {str(e)}")
     def _handle_init_error(self, e: Exception) -> None:
         error_msg = f"Error initializing MainWindowView: {str(e)}"
                 background: {theme['tab_hover_bg_color']};
             }}
         """)
+    def show_window(self) -> None:
+        """Shows the window without repositioning"""
+        self.show()
+        self.repaint()

src/views/MultitargetingWindowView.py CHANGED Viewed

@@ -1,108 +1,370 @@
-from PyQt6 import QtWidgets, QtGui, QtCore
-from PyQt6.QtCore import Qt
 from PyQt6.QtGui import QIcon
-from PyQt6 import uic
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg
 from matplotlib.figure import Figure
-import models.GlobalSettings as GlobalSettings
 from matplotlib.ticker import MaxNLocator
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
-from utils.ui import show_message, show_error, scale_ui, center_ui
-from PyQt6.QtWidgets import QWidget, QComboBox, QVBoxLayout, QPushButton
-import os
-class MultitargetingWindowView(QWidget):
-    def __init__(self, settings):
         super().__init__()
-        self.settings = settings
-        self._init_ui()
-    def _init_ui(self):
         try:
-            self._load_ui_file()
-            # self._init_ui_elements()
-            # self._scale_ui()
         except Exception as e:
-            self._handle_init_error(e)
-    def _handle_init_error(self, e: Exception):
-        error_msg = f"Error initializing MultitargetingWindowView: {str(e)}"
-        self.settings.logger.error(error_msg, exc_info=True)
-        show_error(self.settings, "Initialization Error", error_msg)
-        raise
-    def _load_ui_file(self):
-        ui_file = os.path.join(self.settings.get_ui_dir(), "multitargeting_window.ui")
-        uic.loadUi(ui_file, self)
-    def scaleUI(self):
-        # Implement scaling logic if needed
-        pass
-    def centerUI(self):
-        # Implement centering logic if needed
-        pass
-    def update_table(self, data):
-        # Implement table update logic
-        pass
-    def update_global_stats(self, model):
-        # Implement global stats update logic
-        pass
-    def update_global_line_graph(self, data):
-        # Implement line graph update logic
-        pass
-    def update_global_bar_graph(self, data):
-        # Implement bar graph update logic
-        pass
-    # Add other methods as needed
-class MplCanvas(FigureCanvasQTAgg):
-    def __init__(self, parent=None, width=5, height=4, dpi=100):
         try:
-            fig = Figure(dpi=dpi, tight_layout=True)
-            self.axes = fig.add_subplot(111)
-            self.axes.clear()
-            super(MplCanvas, self).__init__(fig)
         except Exception as e:
-            show_error(self.settings, "Error initializing MplCanvas class in MultitargetingWindowView.", e)
-class LoadingWindow(QtWidgets.QMainWindow):
-    def __init__(self):
         try:
-            super(LoadingWindow, self).__init__()
-            uic.loadUi(GlobalSettings.appdir + "ui/loading_data_form.ui", self)
-            self.setWindowIcon(QIcon(GlobalSettings.appdir + "cas9image.ico"))
-            self.loading_bar.setValue(0)
-            self.setWindowTitle("Loading Data")
-            scale_ui(self, custom_scale_width=450, custom_scale_height=125)
         except Exception as e:
-            show_error(self.settings, "Error initializing LoadingWindow class in MultitargetingWindowView.", e)
-class MultitargetingStatisticsView(QtWidgets.QMainWindow):
-    def __init__(self, parent=None):
         try:
-            super(MultitargetingStatisticsView, self).__init__(parent)
-            uic.loadUi(GlobalSettings.appdir + 'ui/multitargeting_stats.ui', self)
-            self.setWindowIcon(QIcon(GlobalSettings.appdir + "cas9image.ico"))
-            self.setWindowTitle("Statistics")
-            scale_ui(self, custom_scale_width=275, custom_scale_height=185)
         except Exception as e:
-            show_error(self.settings, "Error initializing MultitargetingStatisticsView class in MultitargetingWindowView.", e)
-class SqlQuerySettingsView(QtWidgets.QMainWindow):
-    def __init__(self):
         try:
-            super(SqlQuerySettingsView, self).__init__()
-            uic.loadUi(GlobalSettings.appdir + "ui/multitargeting_sql_settings.ui", self)
-            self.setWindowTitle("SQL Settings")
-            self.setWindowIcon(QIcon(GlobalSettings.appdir + "cas9image.ico"))
-            self.row_count.setValidator(QtGui.QIntValidator())
-            scale_ui(self, custom_scale_width=375, custom_scale_height=140)
         except Exception as e:
-            show_error(self.settings, "Error initializing SqlQuerySettingsView class in MultitargetingWindowView.", e)

+from typing import Optional
+from PyQt6 import QtWidgets, uic, QtGui
+from PyQt6.QtWidgets import QTableWidgetItem, QAbstractItemView
 from PyQt6.QtGui import QIcon
+from PyQt6.QtCore import Qt
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg, NavigationToolbar2QT
 from matplotlib.figure import Figure
 from matplotlib.ticker import MaxNLocator
+from utils.ui import show_error, scale_ui
+class MultitargetingWindowView(QtWidgets.QMainWindow):
+    def __init__(self, global_settings):
         super().__init__()
+        self.settings = global_settings
+        self.logger = self.settings.get_logger()
+        self.init_ui()
+    def init_ui(self):
         try:
+            uic.loadUi(self.settings.get_ui_dir_path() + '/multitargeting_window.ui', self)
+            self._init_ui_components()
         except Exception as e:
+            show_error(self.settings, "Error initializing MultitargetingWindowView", str(e))
+    def _init_ui_components(self):
+        self._init_grpSelectOrganism()
+        self._init_grpSeedAnalysis()
+        self._init_grpGlobalAnalysis()
+    def _init_grpSelectOrganism(self):
+        self.combo_box_organism = self._find_widget('cmbOrganism', QtWidgets.QComboBox)
+        self.combo_box_endonuclease = self._find_widget('cmbEndonuclease', QtWidgets.QComboBox)
+        self.push_button_analyze = self._find_widget('pbtnAnalyze', QtWidgets.QPushButton)
+        self.check_box_select_all = self._find_widget('chkSelectAll', QtWidgets.QCheckBox)
+        self.tool_button_sql_settings = self._find_widget('tbtnSQLSettings', QtWidgets.QToolButton)
+        self.table_seeds = self._find_widget('tblSeeds', QtWidgets.QTableWidget)
+        self.table_seeds.setColumnCount(8)
+        self.table_seeds.setHorizontalHeaderLabels(["Seed", "Total Repeats", "Avg. Repeats/Scaffold", "Consensus Sequence", "% Consensus", "Score", "PAM", "Strand"])
+        self.table_seeds.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.table_seeds.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.table_seeds.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        self.table_seeds.horizontalHeader().setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeMode.Stretch)
+    def _init_grpSeedAnalysis(self):
+        # Get the tab widget
+        self.tab_widget_seed_analysis = self._find_widget('tabsSeedAnalysis', QtWidgets.QTabWidget)
+        # Get screen height for scaling
+        screen = self.screen()
+        height = screen.geometry().height()
+        # Set tab widget to take up less vertical space (e.g., 30% of screen height)
+        tab_height = int((height * 30) / 100)
+        self.tab_widget_seed_analysis.setMinimumHeight(tab_height)
+        self.tab_widget_seed_analysis.setMaximumHeight(tab_height)
+        # Initialize other widgets
+        self.tab_chromosome_viewer = self._find_widget('tabChromosomeViewer', QtWidgets.QWidget)
+        self.graphical_view_chromosome = self._find_widget('graphviewChromosome', QtWidgets.QGraphicsView)
+        self.scroll_chromosome = self._find_widget('scrollChromosome', QtWidgets.QScrollArea)
+        # Create a widget to hold the chromosome visualizations
+        self.chromosome_content_widget = QtWidgets.QWidget()
+        self.chromosome_layout = QtWidgets.QVBoxLayout(self.chromosome_content_widget)
+        self.scroll_chromosome.setWidget(self.chromosome_content_widget)
+        self.scroll_chromosome.setWidgetResizable(True)
+        self.tab_seed_distribution = self._find_widget('tabSeedDistribution', QtWidgets.QWidget)
+        self.plot_repeat_vs_chromosome = self._find_widget('plotRepeatVsChromosome', QtWidgets.QWidget)
+        # Initialize scene for chromosome details
+        self.scene = QtWidgets.QGraphicsScene()
+        self.scene2 = QtWidgets.QGraphicsScene()
+        self.graphical_view_chromosome.setScene(self.scene2)
+        # Set up event filters
+        self.scroll_chromosome.viewport().installEventFilter(self)
+        self.graphical_view_chromosome.viewport().installEventFilter(self)
+        # Dictionary to map canvases to chromosomes
+        self.canvas_chromosome_map = {}
+    def _init_grpGlobalAnalysis(self):
+        self.push_button_statistics_overview = self._find_widget('pbtnStatisticsOverview', QtWidgets.QPushButton)
+        self.tab_repeats_vs_seed = self._find_widget('tabRepeatsVsSeed', QtWidgets.QWidget)
+        self.plot_repeats_vs_seed = self._find_widget('plotRepeatsVsSeed', QtWidgets.QWidget)
+        self.tab_sequences_vs_repeats = self._find_widget('tabSequencesVsRepeats', QtWidgets.QWidget)
+        self.plot_sequences_vs_repeats = self._find_widget('plotSequencesVsRepeats', QtWidgets.QWidget)
+    def _find_widget(self, name: str, widget_type: type) -> Optional[QtWidgets.QWidget]:
+        widget = self.findChild(widget_type, name)
+        if widget is None:
+            self.logger.warning(f"Widget '{name}' not found in UI file.")
+        return widget
+    def update_seeds_table(self, data):
+        """Update the seeds table with the provided data"""
+        self.table_seeds.setRowCount(len(data))
+        for row, row_data in enumerate(data):
+            # Unpack the data
+            (seed, total_count, avg_per_scaffold, sequences,
+             consensus_percent, score, pam, strand) = row_data
+            # Set data in table cells
+            self.table_seeds.setItem(row, 0, QTableWidgetItem(str(seed)))
+            self.table_seeds.setItem(row, 1, QTableWidgetItem(str(total_count)))
+            self.table_seeds.setItem(row, 2, QTableWidgetItem(f"{avg_per_scaffold:.2f}"))
+            self.table_seeds.setItem(row, 3, QTableWidgetItem(sequences.split(',')[0]))  # First sequence
+            self.table_seeds.setItem(row, 4, QTableWidgetItem(f"{consensus_percent:.1f}"))
+            self.table_seeds.setItem(row, 5, QTableWidgetItem(str(score)))
+            self.table_seeds.setItem(row, 6, QTableWidgetItem(str(pam)))
+            self.table_seeds.setItem(row, 7, QTableWidgetItem(str(strand)))
+            # Set alignment for all cells
+            for col in range(8):
+                item = self.table_seeds.item(row, col)
+                if item:
+                    item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.table_seeds.resizeColumnsToContents()
+    def setup_plots(self):
+        """Initialize the matplotlib plots"""
+        self.repeats_vs_seed_canvas = MplCanvas(self, width=8, height=6)
+        self.sequences_vs_repeats_canvas = MplCanvas(self, width=8, height=6)
+        self.repeat_vs_chromosome_canvas = MplCanvas(self, width=8, height=6)
+        # Add canvases to their respective layouts without toolbars
+        for plot_widget, canvas in [
+            (self.plot_repeats_vs_seed, self.repeats_vs_seed_canvas),
+            (self.plot_sequences_vs_repeats, self.sequences_vs_repeats_canvas),
+            (self.plot_repeat_vs_chromosome, self.repeat_vs_chromosome_canvas)
+        ]:
+            layout = QtWidgets.QVBoxLayout(plot_widget)
+            layout.setContentsMargins(0, 0, 0, 0)  # Reduce margins
+            layout.addWidget(canvas)
+    def update_plots(self, repeats_data, sequences_data, chromosome_data):
+        """Update all plots with new data"""
+        self._update_repeats_vs_seed_plot(repeats_data)
+        self._update_sequences_vs_repeats_plot(sequences_data)
+        self._update_repeat_vs_chromosome_plot(chromosome_data)
+    def _update_repeats_vs_seed_plot(self, data):
+        """Update the repeats vs seed line plot"""
         try:
+            self.logger.debug("Starting repeats vs seed plot update")
+            print(f"data: {data}")
+            self.repeats_vs_seed_canvas.axes.clear()
+            if data and 'counts' in data:
+                y1 = data['counts']
+                x = range(len(y1))
+                # Plot with larger markers and line width for better visibility
+                self.repeats_vs_seed_canvas.axes.plot(x, y1, linewidth=1.5, marker='.', markersize=3)
+                # Set labels and title with larger font sizes
+                self.repeats_vs_seed_canvas.axes.set_xlabel('Seed ID Number', fontsize=12)
+                self.repeats_vs_seed_canvas.axes.set_ylabel('Number of Repeats', fontsize=12)
+                self.repeats_vs_seed_canvas.axes.set_title('Number of Repeats per Seed ID Number', fontsize=14)
+                # Set tick label size
+                self.repeats_vs_seed_canvas.axes.tick_params(axis='both', which='major', labelsize=10)
+                # Add grid for better readability
+                self.repeats_vs_seed_canvas.axes.grid(True, linestyle='--', alpha=0.7)
+                # Store statistics if needed
+                if 'stats' in data:
+                    self.average = data['stats']['average']
+                    self.mode = data['stats']['mode']
+                    self.median = data['stats']['median']
+                    self.repeat_count = data['stats']['repeat_count']
+                # Force draw
+                self.repeats_vs_seed_canvas.draw()
+            else:
+                self.logger.warning("No valid data for plotting")
+                self.repeats_vs_seed_canvas.draw()  # Still need to draw even when clearing
         except Exception as e:
+            self.logger.error(f"Error updating repeats vs seed plot: {str(e)}")
+    def _update_sequences_vs_repeats_plot(self, data):
+        """Update the sequences vs repeats plot"""
         try:
+            self.sequences_vs_repeats_canvas.axes.clear()
+            if data and 'x_vals' in data and 'y_vals' in data:
+                x = data['x_vals']
+                y = data['y_vals']
+                # Create scatter plot with specific style
+                self.sequences_vs_repeats_canvas.axes.scatter(x, y, s=15, color='blue')
+                # Set y-axis to log scale
+                self.sequences_vs_repeats_canvas.axes.set_yscale('log')
+                # Set labels and title
+                self.sequences_vs_repeats_canvas.axes.set_xlabel('Number of Repeats', fontsize=12)
+                self.sequences_vs_repeats_canvas.axes.set_ylabel('Number of Sequences', fontsize=12)
+                self.sequences_vs_repeats_canvas.axes.set_title('Number of Sequences per Number of Repeats', fontsize=14)
+                # Set tick label size
+                self.sequences_vs_repeats_canvas.axes.tick_params(axis='both', which='major', labelsize=10)
+                # Add grid for better readability
+                self.sequences_vs_repeats_canvas.axes.grid(True, linestyle='--', alpha=0.7)
+                # Force integer ticks on x-axis
+                self.sequences_vs_repeats_canvas.axes.xaxis.set_major_locator(MaxNLocator(integer=True))
+                # Set axis ranges to match the image
+                self.sequences_vs_repeats_canvas.axes.set_xlim(0, max(x) + 5)  # Add some padding
+                self.sequences_vs_repeats_canvas.axes.set_ylim(1, 10**4)  # Log scale from 1 to 10^4
+            self.sequences_vs_repeats_canvas.draw()
         except Exception as e:
+            self.logger.error(f"Error updating sequences vs repeats plot: {str(e)}")
+    def _update_repeat_vs_chromosome_plot(self, data):
+        """Update the chromosome bar plot"""
         try:
+            self.repeat_vs_chromosome_canvas.axes.clear()
+            if data:
+                y = []
+                x_labels = []
+                # Get sorted chromosome numbers and their counts
+                for chromo in sorted(data.keys()):
+                    x_labels.append(chromo)
+                    y.append(data[chromo])
+                x = list(range(0, len(x_labels)))
+                # Create the bar plot
+                self.repeat_vs_chromosome_canvas.axes.bar(x, y, align='center')
+                # Set integer y-axis
+                self.repeat_vs_chromosome_canvas.axes.yaxis.set_major_locator(MaxNLocator(integer=True))
+                # Set y-axis limits
+                self.repeat_vs_chromosome_canvas.axes.set_ylim(0, max(y) + 1)
+                # Set x-axis ticks and labels
+                self.repeat_vs_chromosome_canvas.axes.set_xticks(x)
+                self.repeat_vs_chromosome_canvas.axes.set_xticklabels(x_labels)
+                # If many chromosomes, show only some labels
+                if len(x_labels) > 10:
+                    tick_spacing = round(len(x_labels)/10)
+                    for i, t in enumerate(self.repeat_vs_chromosome_canvas.axes.get_xticklabels()):
+                        if (i % tick_spacing) != 0:
+                            t.set_visible(False)
+                # Set labels and title
+                self.repeat_vs_chromosome_canvas.axes.set_xlabel('Chromosome', fontsize=10)
+                self.repeat_vs_chromosome_canvas.axes.set_ylabel('Number of Repeats', fontsize=10)
+                self.repeat_vs_chromosome_canvas.axes.set_title('Repeats per Chromosome', fontsize=10)
+                # Set tick label size
+                self.repeat_vs_chromosome_canvas.axes.tick_params(axis='both', which='major', labelsize=8)
+            self.repeat_vs_chromosome_canvas.draw()
         except Exception as e:
+            self.logger.error(f"Error updating repeat vs chromosome plot: {str(e)}")
+    def fill_chromosome_viewer(self, seed_data, event_data):
+        """Fill the chromosome viewer with visualization"""
         try:
+            # Clear out old widgets in layout
+            for i in reversed(range(self.chromosome_layout.count())):
+                self.chromosome_layout.itemAt(i).widget().setParent(None)
+            # Get sorted list of chromosomes
+            chromo_keys = sorted(list(seed_data.keys()))
+            # Get screen height for scaling
+            screen = self.screen()
+            height = screen.geometry().height()
+            groupbox_height = int((height * 100) / 1080)
+            # Create visualization for each chromosome
+            for chromo in chromo_keys:
+                group_box = QtWidgets.QGroupBox()
+                group_box.setTitle(f"Chromosome {chromo}")
+                group_box.setMinimumHeight(groupbox_height)
+                group_box.setMaximumHeight(groupbox_height)
+                layout = QtWidgets.QVBoxLayout(group_box)
+                # Create canvas for this chromosome
+                canvas = MplCanvas()
+                canvas.axes.eventplot(seed_data[chromo])
+                canvas.mpl_connect("motion_notify_event", self._chromosome_event_handler)
+                # Add border lines
+                canvas.axes.hlines(1.5, -0.01, 1.01, colors="Black", linewidth=1.5)
+                canvas.axes.hlines(0.5, -0.01, 1.01, colors="Black", linewidth=1.5)
+                canvas.axes.vlines(-0.01, 0.5, 1.5, colors="Black", linewidth=1.5)
+                canvas.axes.vlines(1.01, 0.5, 1.5, colors="Black", linewidth=1.5)
+                # Set axis limits
+                canvas.axes.set_ylim(0.45, 1.55)
+                canvas.axes.set_xlim(-0.05, 1.05)
+                canvas.axes.axis('off')
+                canvas.draw()
+                # Store canvas mapping
+                self.canvas_chromosome_map[canvas] = chromo
+                self.event_data = event_data  # Store event data for hover details
+                layout.addWidget(canvas)
+                self.chromosome_layout.addWidget(group_box)
+        except Exception as e:
+            show_error(self.settings, "Error in fill_chromosome_viewer", str(e))
+    def _chromosome_event_handler(self, event):
+        """Handle mouse events on chromosome visualization"""
+        try:
+            # Get current mouse location
+            x = event.xdata
+            y = event.y
+            if x is None:  # Mouse outside the plot
+                return
+            # Get event data relative to the canvas
+            curr_chromosome = self.canvas_chromosome_map[event.canvas]
+            chromosome_seed_data = self.event_data[curr_chromosome]
+            # Get targets within range of mouse location
+            local_targets = []
+            for entry in chromosome_seed_data:
+                try:
+                    if abs(x - entry[0]) <= 0.001:
+                        local_targets.append(entry)
+                except:
+                    pass
+            # Update viewer with target details if found
+            if local_targets:
+                self.scene2 = QtWidgets.QGraphicsScene()
+                self.graphical_view_chromosome.setScene(self.scene2)
+                output = ""
+                for target in local_targets:
+                    output += f"Location: {target[1]} | Seq: {target[2]} | PAM: {target[3]} | SCR: {target[4]} | DIRA: {target[5]}\n"
+                text = self.scene2.addText(output)
+                font = QtGui.QFont()
+                font.setPointSize(self.settings.fontSize if hasattr(self.settings, 'fontSize') else 12)
+                text.setFont(font)
         except Exception as e:
+            self.logger.error(f"Error in chromosome event handler: {str(e)}")
+class MplCanvas(FigureCanvasQTAgg):
+    def __init__(self, parent=None, width=8, height=6, dpi=100):
+        fig = Figure(figsize=(width, height), dpi=dpi, tight_layout=True)
+        self.axes = fig.add_subplot(111)
+        super(MplCanvas, self).__init__(fig)

src/views/NCBIRenameWindowView.py CHANGED Viewed

@@ -5,7 +5,8 @@ class NCBIRenameWindowView(QtWidgets.QDialog):
     def __init__(self, settings, files):
         super(NCBIRenameWindowView, self).__init__()
         self.settings = settings
-        self.files = files
         self.setup_ui()
     def setup_ui(self):
@@ -42,6 +43,7 @@ class NCBIRenameWindowView(QtWidgets.QDialog):
     def populate_table(self):
         self.rename_table.setRowCount(len(self.files))
         for row, file in enumerate(self.files):
             item = QtWidgets.QTableWidgetItem(file)
             item.setFlags(QtCore.Qt.ItemFlag.ItemIsEnabled)
             self.rename_table.setItem(row, 0, item)

     def __init__(self, settings, files):
         super(NCBIRenameWindowView, self).__init__()
         self.settings = settings
+        # Store only filenames, not full paths
+        self.files = [os.path.basename(file) for file in files]
         self.setup_ui()
     def setup_ui(self):
     def populate_table(self):
         self.rename_table.setRowCount(len(self.files))
         for row, file in enumerate(self.files):
+            # Create item with just the filename
             item = QtWidgets.QTableWidgetItem(file)
             item.setFlags(QtCore.Qt.ItemFlag.ItemIsEnabled)
             self.rename_table.setItem(row, 0, item)

src/views/NCBIWindowView.py CHANGED Viewed

@@ -4,76 +4,110 @@ import os
 from typing import Optional
 class NCBIWindowView(QtWidgets.QMainWindow):
     def __init__(self, settings):
         super(NCBIWindowView, self).__init__()
         self.settings = settings
         self.logger = settings.get_logger()
         self.progress_bars = {}
         self.progress_labels = {}
-        self.setup_ui()
-    def setup_ui(self):
-        uic.loadUi(os.path.join(self.settings.get_ui_dir_path(), "ncbi_window_v2.ui"), self)
-        self._init_ui_components()
     def _init_ui_components(self) -> None:
-        self._init_grpStep1()
-        self._init_grpStep2()
-        self._init_grpStep3()
     def _init_grpStep1(self) -> None:
-        self.line_edit_organism = self._find_widget("ledOrganism", QtWidgets.QLineEdit)
-        self.line_edit_strain = self._find_widget("ledStrain", QtWidgets.QLineEdit)
-        self.line_edit_max_results = self._find_widget("ledMaxResults", QtWidgets.QLineEdit)
-        self.check_box_complete_genomes_only = self._find_widget("chkCompleteGenomesOnly", QtWidgets.QCheckBox)
     def _init_grpStep2(self) -> None:
-        self.push_button_search = self._find_widget("pbtnSearch", QtWidgets.QPushButton)
-        self.check_box_select_all_rows = self._find_widget("chkSelectAllRows", QtWidgets.QCheckBox)
-        self.table_ncbi_results = self._find_widget("tblNCBIResults", QtWidgets.QTableView)
     def _init_grpStep3(self) -> None:
-        self.radio_button_collections_refseq = self._find_widget("rbtnCollectionsRefSeq", QtWidgets.QRadioButton)
-        self.radio_button_collections_genbank = self._find_widget("rbtnCollectionsGenBank", QtWidgets.QRadioButton)
-        self.check_box_file_types_fna = self._find_widget("chkFileTypesFNA", QtWidgets.QCheckBox)
-        self.check_box_file_types_gbff = self._find_widget("chkFileTypesGBFF", QtWidgets.QCheckBox)
-        self.push_button_download_files = self._find_widget("pbtnDownloadFiles", QtWidgets.QPushButton)
-        self.progress_bar_download_files = self._find_widget("pbDownloadFiles", QtWidgets.QProgressBar)
-        self.label_download_files_status = self._find_widget("lblDownloadFilesStatus", QtWidgets.QLabel)
-        self.progress_bar_download_files.setValue(0)
-    def _find_widget(self, name: str, widget_type: type) -> Optional[QtWidgets.QWidget]:
-        widget = self.findChild(widget_type, name)
-        if widget is None:
-            self.settings.logger.warning(f"Widget '{name}' not found in UI file.")
-        return widget
-    def set_styles(self):
-        groupbox_style = """
-        QGroupBox:title{subcontrol-origin: margin;
-                        left: 10px;
-                        padding: 0 5px 0 5px;}
-        QGroupBox#Step1{border: 2px solid rgb(111,181,110);
-                        border-radius: 9px;
-                        font: bold 14pt 'Arial';
-                        margin-top: 10px;}"""
-        self.Step1.setStyleSheet(groupbox_style)
-        self.Step2.setStyleSheet(groupbox_style.replace("Step1","Step2"))
-        self.Step3.setStyleSheet(groupbox_style.replace("Step1","Step3"))
     def populate_ncbi_table(self, model):
         self.table_ncbi_results.setModel(model)
         # Set selection behavior to select entire rows
         self.table_ncbi_results.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectionBehavior.SelectRows)
         self.table_ncbi_results.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.MultiSelection)
         # Set the horizontal header to resize mode
         header = self.table_ncbi_results.horizontalHeader()
         header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeMode.Interactive)
@@ -104,6 +138,9 @@ class NCBIWindowView(QtWidgets.QMainWindow):
         # Ensure the last column doesn't stretch
         header.setStretchLastSection(False)
     def get_search_parameters(self):
         return {
@@ -145,3 +182,8 @@ class NCBIWindowView(QtWidgets.QMainWindow):
         if source_model:
             source_model.clear()
         self.table_ncbi_results.reset()

 from typing import Optional
 class NCBIWindowView(QtWidgets.QMainWindow):
+    initialization_complete = QtCore.pyqtSignal()  # New signal
     def __init__(self, settings):
         super(NCBIWindowView, self).__init__()
         self.settings = settings
         self.logger = settings.get_logger()
         self.progress_bars = {}
         self.progress_labels = {}
+        self._is_initialized = False  # Track initialization state
+        self._setup_basic_ui()  # Only do basic initialization first
+    def _setup_basic_ui(self):
+        """Initial minimal setup to show the window quickly"""
+        try:
+            uic.loadUi(os.path.join(self.settings.get_ui_dir_path(), "ncbi_window_v2.ui"), self)
+            QtCore.QTimer.singleShot(100, self._complete_initialization)
+        except Exception as e:
+            self.logger.error(f"Error in basic UI setup: {str(e)}")
+            raise
+    def _complete_initialization(self):
+        """Complete the full initialization of UI components"""
+        try:
+            if self._is_initialized:
+                return
+            # Initialize all UI components
+            self._init_ui_components()
+            self._is_initialized = True
+            self.logger.debug("NCBI Window initialization completed")
+            # Emit signal after everything is initialized
+            self.initialization_complete.emit()
+        except Exception as e:
+            self.logger.error(f"Error in complete initialization: {str(e)}")
+            raise
     def _init_ui_components(self) -> None:
+        """Initialize all UI components at once instead of using timers"""
+        try:
+            self._init_grpStep1()
+            self._init_grpStep2()
+            self._init_grpStep3()
+        except Exception as e:
+            self.logger.error(f"Error in _init_ui_components: {str(e)}")
+            raise
     def _init_grpStep1(self) -> None:
+        try:
+            self.line_edit_organism = self._find_widget("ledOrganism", QtWidgets.QLineEdit)
+            self.line_edit_strain = self._find_widget("ledStrain", QtWidgets.QLineEdit)
+            self.line_edit_max_results = self._find_widget("ledMaxResults", QtWidgets.QLineEdit)
+            self.check_box_complete_genomes_only = self._find_widget("chkCompleteGenomesOnly", QtWidgets.QCheckBox)
+            # Set default values
+            self.line_edit_max_results.setText("100")
+        except Exception as e:
+            self.logger.error(f"Error initializing Step 1: {str(e)}")
     def _init_grpStep2(self) -> None:
+        try:
+            self.push_button_search = self._find_widget("pbtnSearch", QtWidgets.QPushButton)
+            self.check_box_select_all_rows = self._find_widget("chkSelectAllRows", QtWidgets.QCheckBox)
+            self.table_ncbi_results = self._find_widget("tblNCBIResults", QtWidgets.QTableView)
+        except Exception as e:
+            self.logger.error(f"Error initializing Step 2: {str(e)}")
     def _init_grpStep3(self) -> None:
+        try:
+            self.radio_button_collections_refseq = self._find_widget("rbtnCollectionsRefSeq", QtWidgets.QRadioButton)
+            self.radio_button_collections_genbank = self._find_widget("rbtnCollectionsGenBank", QtWidgets.QRadioButton)
+            self.check_box_file_types_fna = self._find_widget("chkFileTypesFNA", QtWidgets.QCheckBox)
+            self.check_box_file_types_gbff = self._find_widget("chkFileTypesGBFF", QtWidgets.QCheckBox)
+            self.push_button_download_files = self._find_widget("pbtnDownloadFiles", QtWidgets.QPushButton)
+            self.progress_bar_download_files = self._find_widget("pbDownloadFiles", QtWidgets.QProgressBar)
+            self.label_download_files_status = self._find_widget("lblDownloadFilesStatus", QtWidgets.QLabel)
+            # Set initial states
+            self.progress_bar_download_files.setValue(0)
+            self.radio_button_collections_refseq.setChecked(True)
+            self.check_box_file_types_fna.setChecked(True)
+        except Exception as e:
+            self.logger.error(f"Error initializing Step 3: {str(e)}")
     def populate_ncbi_table(self, model):
+        """Populate the table with data and set up proper row selection"""
         self.table_ncbi_results.setModel(model)
         # Set selection behavior to select entire rows
         self.table_ncbi_results.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectionBehavior.SelectRows)
         self.table_ncbi_results.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.MultiSelection)
+        # Disable cell editing
+        self.table_ncbi_results.setEditTriggers(QtWidgets.QAbstractItemView.EditTrigger.NoEditTriggers)
+        # Enable sorting
+        self.table_ncbi_results.setSortingEnabled(True)
         # Set the horizontal header to resize mode
         header = self.table_ncbi_results.horizontalHeader()
         header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeMode.Interactive)
         # Ensure the last column doesn't stretch
         header.setStretchLastSection(False)
+        # Set focus policy to enable keyboard selection
+        self.table_ncbi_results.setFocusPolicy(QtCore.Qt.FocusPolicy.StrongFocus)
     def get_search_parameters(self):
         return {
         if source_model:
             source_model.clear()
         self.table_ncbi_results.reset()
+    def _find_widget(self, name: str, widget_type: type) -> Optional[QtWidgets.QWidget]:
+        widget = self.findChild(widget_type, name)
+        if widget is None:
+            self.settings.logger.warning(f"Widget '{name}' not found in UI file.")
+        return widget

src/views/NewEndonuclease.py DELETED Viewed

@@ -1,228 +0,0 @@
-import sys, os
-from PyQt5 import QtWidgets, uic, QtGui, QtCore, Qt
-import models.GlobalSettings as GlobalSettings
-from PyQt5.QtGui import QIntValidator
-import traceback
-import math
-from utils.ui import show_message, show_error, scale_ui, center_ui
-logger = GlobalSettings.logger
-class NewEndonuclease(QtWidgets.QMainWindow):
-    def __init__(self):
-        print("Initializing NewEndonuclease class")
-        try:
-            super(NewEndonuclease, self).__init__()
-            uic.loadUi(GlobalSettings.appdir + 'ui/newendonuclease.ui', self)
-            self.setWindowIcon(Qt.QIcon(GlobalSettings.appdir + "cas9image.ico"))
-            self.setWindowTitle('New Endonuclease')
-            self.error = False
-            pamFlag = False
-            self.onList = []
-            self.offList = []
-            self.onList, self.offList = self.get_on_off_data() ### Call function to fill on- and off- data name lists
-            for name in self.onList: ### Add on-target names to drop-down
-                self.comboBox.addItem(str(name))
-            for name in self.offList: ### Add off-target names to drop-down
-                self.comboBox_2.addItem(str(name))
-            self.submit_button.clicked.connect(self.submit)
-            self.cancel_button.clicked.connect(self.cancel)
-            ### Set up validators for input fields:
-            reg_ex1 = QtCore.QRegExp("[^/\\\\_]+") # No slashes or underscores
-            reg_ex2 = QtCore.QRegExp("[^/\\\\_\\s]+") # No slashes, underscores, or spaces
-            reg_ex3 = QtCore.QRegExp("[acdefghiklmnpqrstvwyACDEFGHIKLMNPQRSTVWY\S]+") # Only approved PAM characters and no spaces
-            input_validator1 = QtGui.QRegExpValidator(reg_ex1, self)
-            input_validator2 = QtGui.QRegExpValidator(reg_ex2, self)
-            input_validator3 = QtGui.QRegExpValidator(reg_ex3, self)
-            self.organism_name.setValidator(input_validator1)
-            self.abbreviation.setValidator(input_validator2)
-            self.pam_sequence.setValidator(input_validator3)
-            self.seed_length.setValidator(QIntValidator(0,30,self.seed_length))
-            self.five_length.setValidator(QIntValidator(0,20,self.five_length))
-            self.three_length.setValidator(QIntValidator(0,20,self.three_length))
-            groupbox_style = """
-            QGroupBox:title{subcontrol-origin: margin;
-                            left: 10px;
-                            padding: 0 5px 0 5px;}
-            QGroupBox#groupBox{border: 2px solid rgb(111,181,110);
-                            border-radius: 9px;
-                            font: bold 14pt 'Arial';
-                            margin-top: 10px;}"""
-            self.groupBox.setStyleSheet(groupbox_style)
-            self.groupBox_2.setStyleSheet(groupbox_style.replace("groupBox","groupBox_2"))
-            self.groupBox_3.setStyleSheet(groupbox_style.replace("groupBox","groupBox_3"))
-            scale_ui(self, custom_scale_width=480, custom_scale_height=615)
-        except Exception as e:
-            show_error("Error initializing NewEndonuclease class.", e)
-    #helper function for writing new endo information to CASPERinfo - used by submit()
-    def writeNewEndonuclease(self, newEndonucleaseStr):
-        try:
-            with open(GlobalSettings.appdir + 'CASPERinfo', 'r') as f, open(GlobalSettings.appdir + "new_file", 'w+') as f1:
-                for line in f:
-                    f1.write(line)
-                    if 'ENDONUCLEASES' in line:
-                        f1.write(newEndonucleaseStr + '\n')  # Move f1.write(line) above, to write above instead
-            os.remove(GlobalSettings.appdir + "CASPERinfo")
-            os.rename(GlobalSettings.appdir + "new_file",
-                      GlobalSettings.appdir + "CASPERinfo")  # Rename the new file
-        except Exception as e:
-            show_error("Error in writeNewEndonuclease() in New Endonuclease.", e)
-    #submit new endo to CASPERinfo file
-    def submit(self):
-        try:
-            # This is executed when the button is pressed
-            name = str(self.organism_name.text())
-            abbr = str(self.abbreviation.text())
-            crisprtype = str(self.crispr_type.text())
-            seed_len = str(self.seed_length.text())
-            five_len = str(self.five_length.text())
-            three_len = str(self.three_length.text())
-            pam = str(self.pam_sequence.text()).upper()
-            ### Check for multiple PAMs and format if present
-            if len(pam.split(','))>0:
-                pam = [x.strip() for x in pam.split(',')]
-                pam = ",".join(pam)
-            ### Check for PAM directionality
-            if self.five_pam.isChecked():
-                pam_dir = str(5)
-            else:
-                pam_dir = str(3)
-            on_scoring = str(self.comboBox.currentText())
-            off_scoring = str(self.comboBox_2.currentText())
-            length = len(seed_len) + len(five_len) + len(three_len)
-            argument_list = [abbr, pam, five_len, seed_len, three_len, pam_dir, name, crisprtype, on_scoring, off_scoring]
-            validPAM = ('A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y')
-            self.error = False;
-            ### Error checking for PAM alphabet
-            for letter in pam:
-                if (letter not in validPAM):
-                    show_message(
-                        fontSize=12,
-                        icon=QtWidgets.QMessageBox.Icon.Critical,
-                        title="Invalid PAM",
-                        message="Invalid characters in PAM Sequence."
-                    )
-                    return True
-            ### Error checking for filling out all fields
-            for arg in argument_list:
-                if ';' in arg:
-                    show_message(
-                        fontSize=12,
-                        icon=QtWidgets.QMessageBox.Icon.Critical,
-                        title="Invalid Semicolon",
-                        message="Invalid character used: ';'."
-                    )
-                    return True
-                elif arg == "":
-                    show_message(
-                        fontSize=12,
-                        icon=QtWidgets.QMessageBox.Icon.Critical,
-                        title="Empty Field",
-                        message="Please fill in all fields."
-                    )
-                    return True
-                else:
-                    pass
-            ### Check for duplicate endo abbreviations
-            for key in GlobalSettings.mainWindow.organisms_to_endos:
-                endo = GlobalSettings.mainWindow.organisms_to_endos[key]
-                if abbr in endo:
-                    show_message(
-                        fontSize=12,
-                        icon=QtWidgets.QMessageBox.Icon.Critical,
-                        title="Duplicate endo name.",
-                        message="The given abbreviation already exists.  Please choose a unique identifier."
-                    )
-                    return True
-                else:
-                    pass
-            myString = ""
-            for i, arg in enumerate(argument_list):
-                if i == len(argument_list)-1: ### Last argument in list
-                    myString += str(arg)
-                else:
-                    myString += str(arg) + ";"
-            self.writeNewEndonuclease(myString)
-            ### Refresh endonuclease dropdown in New Genome
-            GlobalSettings.mainWindow.newGenome.fillEndo()
-            self.clear_all()
-            self.close()
-        except Exception as e:
-            show_error("Error in submit() in New Endonuclease.", e)
-    #cancel and close window
-    def cancel(self):
-        try:
-            self.clear_all()
-            self.close()
-        except Exception as e:
-            show_error("Error in cancel() in New Endonuclease.", e)
-    # This function clears all of the line edits
-    def clear_all(self):
-        try:
-            self.organism_name.clear()
-            self.abbreviation.clear()
-            self.crispr_type.clear()
-            self.seed_length.clear()
-            self.five_length.clear()
-            self.three_length.clear()
-            self.pam_sequence.clear()
-        except Exception as e:
-            show_error("Error in clear_all() in New Endonuclease.", e)
-    # This function parses CASPERinfo to return the names (in lists) of all on-target and off-target scoring data
-    def get_on_off_data(self):
-        try:
-            filename = GlobalSettings.appdir + "CASPERinfo"
-            retList_on = []
-            retList_off = []
-            with open(filename, 'r') as f:
-                lines = f.readlines()
-                for i, line in enumerate(lines):
-                    line = str(line)
-                    if "ON-TARGET DATA" in line:
-                        index = i
-                        while "-----" not in line:
-                            if "DATA:" in line:
-                                retList_on.append(line.split("DATA:")[-1].strip()) ### Append name of scoring data to on-target name list
-                                line = lines[index+1]
-                                index += 1
-                            else:
-                                line = lines[index+1]
-                                index += 1
-                                continue
-                    elif "OFF-TARGET MATRICES" in line:
-                        index = i
-                        while "-----" not in line:
-                            if "MATRIX:" in line:
-                                retList_off.append(line.split("MATRIX:")[-1].strip()) ### Append name of scoring data to off-target name list
-                                line = lines[index+1]
-                                index += 1
-                            else:
-                                line = lines[index+1]
-                                index += 1
-                                continue
-                    else:
-                        continue
-            return retList_on, retList_off
-        except Exception as e:
-            show_error("Error in get_on_off_data() in New Endonuclease.", e)

src/views/NewGenome.py DELETED Viewed

@@ -1,705 +0,0 @@
-from ast import Global
-import os
-from PyQt5 import QtWidgets, uic, QtGui, QtCore, Qt
-import models.GlobalSettings as GlobalSettings
-from functools import partial
-from utils.Algorithms import SeqTranslate
-import webbrowser
-import platform
-import traceback
-import math
-from utils.ui import show_message, show_error, scale_ui, center_ui
-from utils.web import ncbi_page, repo_page
-logger = GlobalSettings.logger
-def iter_except(function, exception):
-    """Works like builtin 2-argument `iter()`, but stops on `exception`."""
-    try:
-        while True:
-            yield function()
-    except exception:
-        return
-#UI prompt for when the user has finished running jobs in new genome to allow them to choose where the want to proceed
-class goToPrompt(QtWidgets.QMainWindow):
-    def __init__(self):
-        try:
-            super(goToPrompt, self).__init__()
-            uic.loadUi(GlobalSettings.appdir + 'ui/newgenomenavigationpage.ui', self)
-            groupbox_style = """
-            QGroupBox:title{subcontrol-origin: margin;
-                            left: 10px;
-                            padding: 0 5px 0 5px;}
-            QGroupBox#groupBox{border: 2px solid rgb(111,181,110);
-                            border-radius: 9px;
-                            font: bold 14pt 'Arial';
-                            margin-top: 10px;}"""
-            self.groupBox.setStyleSheet(groupbox_style)
-            scale_ui(self, custom_scale_width=575, custom_scale_height=175)
-            self.setWindowTitle("New Genome")
-            self.setWindowIcon(Qt.QIcon(GlobalSettings.appdir + "cas9image.ico"))
-            self.hide()
-        except Exception as e:
-            show_error("Unable to initialize goToPrompt class in New Genome.", e)
-#New genome class to allow users to generate new CSPR files
-class NewGenome(QtWidgets.QMainWindow):
-    def __init__(self, info_path):
-        try:
-            super(NewGenome, self).__init__()
-            uic.loadUi(GlobalSettings.appdir + 'ui/NewGenome.ui', self)
-            self.setWindowTitle('New Genome')
-            self.setWindowTitle('New Genome')
-            self.info_path = info_path
-            #---Style Modifications---#
-            groupbox_style = """
-            QGroupBox:title{subcontrol-origin: margin;
-                            left: 10px;
-                            padding: 0 5px 0 5px;}
-            QGroupBox#Step1{border: 2px solid rgb(111,181,110);
-                            border-radius: 9px;
-                            font: bold 14pt 'Arial';
-                            margin-top: 10px;}"""
-            self.Step1.setStyleSheet(groupbox_style)
-            self.Step2.setStyleSheet(groupbox_style.replace("Step1","Step2"))
-            self.Step3.setStyleSheet(groupbox_style.replace("Step1","Step3"))
-            #---Button Modifications---#
-            self.setWindowIcon(Qt.QIcon(GlobalSettings.appdir + "cas9image.ico"))
-            self.resetButton.clicked.connect(self.reset)
-            self.submitButton.clicked.connect(self.submit)
-            self.browseForFile.clicked.connect(self.selectFasta)
-            self.remove_job.clicked.connect(self.remove_from_queue)
-            self.output_browser.setText("Waiting for program initiation...")
-            self.contButton.clicked.connect(self.continue_to_main)
-            self.comboBoxEndo.currentIndexChanged.connect(self.endo_settings)
-            self.runButton.clicked.connect(self.run_jobs_wrapper)
-            self.clearButton.clicked.connect(self.clear_all)
-            self.JobsQueue = []  # holds Job classes.
-            self.check_strings = []
-            self.Endos = dict()
-            self.file = ""
-            self.process = QtCore.QProcess()
-            self.process.setProcessChannelMode(QtCore.QProcess.MergedChannels)
-            self.process.finished.connect(self.upon_process_finishing)
-            self.seqTrans = SeqTranslate()
-            self.exit = False
-            self.first = False
-            #show functionalities on window
-            self.fillEndo()
-            self.num_chromo_next = False
-            #Jobs Table
-            self.job_Table.setShowGrid(False)
-            self.job_Table.horizontalHeader().setSectionsClickable(True)
-            self.job_Table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
-            self.job_Table.setEditTriggers(QtWidgets.QAbstractItemView.NoEditTriggers)
-            self.job_Table.setSelectionMode(QtWidgets.QAbstractItemView.MultiSelection)
-            self.job_Table.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)
-            self.fin_index=0
-            self.mwfg = self.frameGeometry()  ##Center window
-            self.cp = QtWidgets.QDesktopWidget().availableGeometry().center()  ##Center window
-            self.total_chrom_count = 0
-            self.perc_increase = 0
-            self.progress = 0
-            #toolbar button actions
-            self.visit_repo.triggered.connect(repo_page)
-            self.go_ncbi.triggered.connect(ncbi_page)
-            self.comboBoxEndo.currentIndexChanged.connect(self.changeEndos)
-            ### NCBI tool
-            self.NCBI_File_Search.clicked.connect(self.open_ncbi_tool)
-            self.seed_length.setEnabled(False)
-            self.five_length.setEnabled(False)
-            self.three_length.setEnabled(False)
-            self.repeats_box.setEnabled(False)
-            ### User prompt class
-            self.goToPrompt = goToPrompt()
-            self.goToPrompt.goToMain.clicked.connect(self.continue_to_main)
-            self.goToPrompt.goToMT.clicked.connect(self.continue_to_MT)
-            self.goToPrompt.goToPop.clicked.connect(self.continue_to_pop)
-            self.orgName.setFocus()
-            ### Connect New endonuclease to New Genome
-            self.actionUpload_New_Endonuclease.triggered.connect(self.launch_newEndonuclease)
-            ### Set up validators for input fields:
-            reg_ex1 = QtCore.QRegExp("[^/\\\\_]+") # No slashes or underscores
-            reg_ex2 = QtCore.QRegExp("\\S+")
-            input_validator1 = QtGui.QRegExpValidator(reg_ex1, self)
-            input_validator2 = QtGui.QRegExpValidator(reg_ex2, self)
-            self.orgName.setValidator(input_validator1)
-            self.strainName.setValidator(input_validator1)
-            self.orgCode.setValidator(input_validator2)
-            scale_ui(self, custom_scale_width=850, custom_scale_height=750)
-            self.first_show = True
-        except Exception as e:
-            show_error("Error initializing New Genome class.", e)
-    def launch_newEndonuclease(self):
-        try:
-            GlobalSettings.mainWindow.getData()
-            GlobalSettings.mainWindow.newEndonuclease.centerUI()
-            GlobalSettings.mainWindow.newEndonuclease.show()
-            GlobalSettings.mainWindow.newEndonuclease.activateWindow()
-        except Exception as e:
-            show_error("Error in launch_newEndonuclease() in New Genome.", e)
-    #open the ncbi search tool window
-    def open_ncbi_tool(self):
-        try:
-            #center ncbi on current screen
-            if GlobalSettings.mainWindow.ncbi.first_show == True:
-                GlobalSettings.mainWindow.ncbi.first_show = False
-                GlobalSettings.mainWindow.ncbi.centerUI()
-            if self.orgName.text() != "":
-                GlobalSettings.mainWindow.ncbi.organism_line_edit.setText(self.orgName.text())
-            if self.strainName.text() != "":
-                GlobalSettings.mainWindow.ncbi.infra_name_line_edit.setText(self.strainName.text())
-            GlobalSettings.mainWindow.ncbi.show()
-            GlobalSettings.mainWindow.ncbi.activateWindow()
-        except Exception as e:
-            show_error("Error in open_ncbi_tool() in New Genome.", e)
-    def remove_from_queue(self):
-        try:
-            while(True):
-                indexes = self.job_Table.selectionModel().selectedRows()
-                if len(indexes) == 0:
-                    break
-                self.job_Table.removeRow(indexes[0].row())
-        except Exception as e:
-            show_error("Error in remove_from_queue() in New Genome.", e)
-    #prompt user with file browser to select fasta/fna files
-    def selectFasta(self):
-        try:
-            filed = QtWidgets.QFileDialog()
-            myFile = QtWidgets.QFileDialog.getOpenFileName(filed, "Choose a File")
-            if (myFile[0] != ""):
-                if not myFile[0].endswith(".fa") and not myFile[0].endswith(".fna") and not myFile[0].endswith(".fasta"):
-                    show_message(
-                        fontSize=12,
-                        icon=QtWidgets.QMessageBox.Icon.Critical,
-                        title="File Selection Error",
-                        message="You have selected an incorrect type of file. Please choose a FASTA/FNA file."
-                    )
-                    return
-                else:
-                    self.file = myFile[0]
-                    self.selectedFile.setText(str(myFile[0]))
-        except Exception as e:
-            show_error("Error in selectFasta() in New Genome.", e)
-    #submit jobs to queue
-    def submit(self):
-        try:
-            warning = ""
-            if len(self.orgName.text()) == 0:
-                warning = warning + "You need to include the organism's name."
-            if len(self.file) == 0:
-                warning = warning + "You need to select a file."
-            if len(warning) != 0:
-                show_message(
-                    fontSize=12,
-                    icon=QtWidgets.QMessageBox.Icon.Critical,
-                    title="Required Information",
-                    message=warning
-                )
-                return
-            if len(self.strainName.text()) == 0:
-                warning = warning + "\nIt is recommended to include the organism's subspecies/strain."
-            if len(self.orgCode.text()) == 0:
-                warning = warning + "\nYou must include an organism code."
-            if len(warning) != 0:
-                msgBox = QtWidgets.QMessageBox()
-                msgBox.setStyleSheet("font: " + str(self.fontSize) + "pt 'Arial'")
-                msgBox.setIcon(QtWidgets.QMessageBox.Icon.Question)
-                msgBox.setWindowTitle("Missing Information")
-                msgBox.setText(warning + "\n\nDo you wish to continue without including this information?")
-                msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Yes)
-                msgBox.addButton(QtWidgets.QMessageBox.StandardButton.No)
-                msgBox.exec()
-                if msgBox.result() == QtWidgets.QMessageBox.No:
-                    return
-            #endo, pam, repeats, directionality, five length, seed length, three length, orgcode, output path, CASPERinfo path, fna path, orgName, notes, on target matrix
-            args = self.Endos[self.comboBoxEndo.currentText()][0]
-            args += " " + self.Endos[self.comboBoxEndo.currentText()][1]
-            if self.mt.isChecked():
-                args += " " + "TRUE"
-            else:
-                args += " " + "FALSE"
-            if self.Endos[self.comboBoxEndo.currentText()][5] == "3":
-                args += " " + "FALSE"
-            else:
-                args += " " + "TRUE"
-            if self.repeats_box.isChecked():
-                args += " " + "TRUE"
-            else:
-                args += " " + "FALSE"
-            args += " " + self.Endos[self.comboBoxEndo.currentText()][2]
-            args += " " + self.Endos[self.comboBoxEndo.currentText()][3]
-            args += " " + self.Endos[self.comboBoxEndo.currentText()][4]
-            args += " " + self.orgCode.text()
-            if platform.system() == 'Windows':
-                args += " " + '"' + GlobalSettings.CSPR_DB.replace("/","\\") + '\\"'
-                args += " " + '"' + GlobalSettings.appdir.replace("/","\\") + "CASPERinfo" + '"'
-                args += " " + '"' + self.file.replace("/","\\") + '"'
-            else:
-                args += " " + '"' + GlobalSettings.CSPR_DB.replace("\\","/") + '/"'
-                args += " " + '"' + GlobalSettings.appdir.replace("\\","/") + "CASPERinfo" + '"'
-                args += " " + '"' + self.file.replace("\\","/") + '"'
-            args += " " + '"' + self.orgName.text() + " " + self.strainName.text() + '"'
-            args += " " + '"' + "notes" + '"'
-            args += " " + '"DATA:' + self.Endos[self.comboBoxEndo.currentText()][6] + '"'
-            tmp = self.orgName.text()+ " " + self.strainName.text() + " " + self.Endos[self.comboBoxEndo.currentText()][0] + " " + self.orgCode.text()
-            if tmp in self.check_strings:
-                show_message(
-                    fontSize=12,
-                    icon=QtWidgets.QMessageBox.Icon.Critical,
-                    title="Duplicate Entry",
-                    message="You have submitted a duplicate entry. Consider changing the organism code or strain name to differentiate closely related strains."
-                )
-                return
-            name = self.orgCode.text() + "_" + str(self.Endos[self.comboBoxEndo.currentText()][0])
-            rowPosition = self.job_Table.rowCount()
-            self.job_Table.insertRow(rowPosition)
-            item = QtWidgets.QTableWidgetItem(name)
-            item.setTextAlignment(QtCore.Qt.AlignHCenter)
-            self.job_Table.setItem(rowPosition, 0, item)
-            self.check_strings.append(tmp)
-            self.JobsQueue.append(args)
-        except Exception as e:
-            show_error("Error in submit() in New Genome.", e)
-    #fill the endo dropdown
-    def fillEndo(self):
-        try:
-            #disconnect signal
-            try:
-                self.comboBoxEndo.currentIndexChanged.disconnect()
-            except:
-                pass
-            #clear out the endo box
-            self.comboBoxEndo.clear()
-            f = open(GlobalSettings.appdir + "CASPERinfo")
-            while True:
-                line = f.readline()
-                if line.startswith('ENDONUCLEASES'):
-                    while True:
-                        line = f.readline()
-                        if (line[0] == "-"):
-                            break
-                        line_tokened = line.split(";")
-                        if len(line_tokened) == 10:
-                            endo = line_tokened[0]
-                            # Checking to see if there is more than one pam sequence in the list
-                            if line_tokened[1].find(",") != -1:
-                                p_pam = line_tokened[1].split(",")[0]
-                            else:
-                                p_pam = line_tokened[1]
-                            five_length = line_tokened[2]
-                            seed_length = line_tokened[3]
-                            three_length = line_tokened[4]
-                            dir = line_tokened[5]
-                            on_target_data = line_tokened[8]
-                            self.Endos[endo + " - PAM: " + p_pam] = (endo, p_pam, five_length, seed_length, three_length, dir, on_target_data)
-                    break
-            f.close()
-            self.comboBoxEndo.addItems(self.Endos.keys())
-            key = list(self.Endos.keys())[0]
-            self.seed_length.setText(self.Endos[key][3])
-            self.five_length.setText(self.Endos[key][2])
-            self.three_length.setText(self.Endos[key][4])
-            #reconnect signal
-            self.comboBoxEndo.currentIndexChanged.connect(self.changeEndos)
-        except Exception as e:
-            show_error("Error in fillEndo() in New Genome.", e)
-    #event handler for endo changing - update endo length data
-    def changeEndos(self):
-        try:
-            key = str(self.comboBoxEndo.currentText())
-            self.seed_length.setText(self.Endos[key][3])
-            self.five_length.setText(self.Endos[key][2])
-            self.three_length.setText(self.Endos[key][4])
-        except Exception as e:
-            show_error("Error in changeEndos() in New Genome.", e)
-    #check if endo is 3' or 5'
-    def endo_settings(self):
-        try:
-            # check the if it's 3' or 5', and check the box accordingly
-            if int(self.seqTrans.endo_info[self.Endos[self.comboBoxEndo.currentText()][0]][3]) == 3:
-                self.pamBox.setChecked(0)
-            elif int(self.seqTrans.endo_info[self.Endos[self.comboBoxEndo.currentText()][0]][3]) == 5:
-                self.pamBox.setChecked(1)
-        except Exception as e:
-            show_error("Error in endo_settings() in New Genome.", e)
-    #wrapper for running jobs
-    def run_jobs_wrapper(self):
-        try:
-            self.indexes = []
-            self.job_Table.selectAll()
-            indexes = self.job_Table.selectionModel().selectedRows()
-            for index in sorted(indexes):
-                if self.job_Table.item(index.row(), 0).text() != "":
-                    self.indexes.append(index.row())
-            self.run_job()
-        except Exception as e:
-            show_error("Error in run_jobs_wrapper() in New Genome.", e)
-    #run job in queue
-    def run_job(self):
-        try:
-            if len(self.indexes) > 0:
-                self.progressBar.setValue(0)
-                self.progress = 0
-                row_index = self.indexes[0]
-                name = self.job_Table.item(row_index, 0).text()
-                item = QtWidgets.QTableWidgetItem(name)
-                item.setTextAlignment(QtCore.Qt.AlignHCenter)
-                self.job_Table.setItem(row_index, 1, item)
-                self.job_Table.setItem(row_index, 0, QtWidgets.QTableWidgetItem(""))
-                def output_stdout(p):
-                    line = str(p.readAll())
-                    line = line[2:]
-                    line = line[:len(line) - 1]
-                    for lines in line.split(r"\n"):
-                        lines = lines.rstrip("\n")
-                        lines = lines.rstrip("\r")
-                        lines = lines.rstrip(r"\n")
-                        lines = lines.rstrip(r"\r")
-                        lines = lines.rstrip("\r\n")
-                        lines = lines.rstrip(r"\r\n")
-                        if lines != "":
-                            if lines.find("Number of Chromosomes/Scaffolds") != -1:
-                                copy = lines
-                                copy = copy.replace(" ","")
-                                copy = copy[copy.find(":")+1:]
-                                self.total_chrom_count = int(copy)
-                                self.perc_increase = ((1 / (2 * self.total_chrom_count)) * 70)
-                                self.progressBar.setValue(20)
-                                self.progress = 20
-                            elif lines.find("complete.") != -1:
-                                self.progress += self.perc_increase
-                                self.progressBar.setValue(int(self.progress))
-                            elif lines.find("Processing Targets.") != -1:
-                                self.progress = 70
-                                self.progressBar.setValue(int(self.progress))
-                            elif lines.find("Writing out uniques.") != -1:
-                                self.progress = 90
-                                self.progressBar.setValue(int(self.progress))
-                            elif lines.find("Writing out repeats.") != -1:
-                                self.progress = 95
-                                self.progressBar.setValue(int(self.progress))
-                            elif lines == "Finished.":
-                                self.progress = 100
-                                self.progressBar.setValue(int(self.progress))
-                            self.output_browser.append(lines)
-                job_args = self.JobsQueue[row_index]
-                if platform.system() == 'Windows':
-                    program = '"' + GlobalSettings.appdir + "SeqFinderFolder/Casper_Seq_Finder_Win.exe" + '" '
-                elif platform.system() == 'Linux':
-                    program = '"' + GlobalSettings.appdir + "SeqFinderFolder/Casper_Seq_Finder_Lin" + '" '
-                else:
-                    program = '"' + GlobalSettings.appdir + "SeqFinderFolder/Casper_Seq_Finder_Mac" + '" '
-                program += job_args
-                self.process.readyReadStandardOutput.connect(partial(output_stdout, self.process))
-                self.process.start(program)
-            else:
-                show_message(
-                    fontSize=12,
-                    icon=QtWidgets.QMessageBox.Icon.Critical,
-                    title="No Jobs To Run",
-                    message="No jobs are in the queue to run. Please add a job before running."
-                )
-        except Exception as e:
-            show_error("Error in run_job() in New Genome.", e)
-    #even handler for when jobs finish execution
-    def upon_process_finishing(self):
-        try:
-            row_index = self.indexes[0]
-            name = self.job_Table.item(row_index, 1).text()
-            item = QtWidgets.QTableWidgetItem(name)
-            item.setTextAlignment(QtCore.Qt.AlignHCenter)
-            self.job_Table.setItem(row_index, 2, item)
-            self.job_Table.setItem(row_index, 1, QtWidgets.QTableWidgetItem(""))
-            self.indexes.pop(0)
-            if len(self.indexes) != 0:
-                self.run_job()
-            else:
-                #prompt user if they want to analyze their new files
-                center_ui(self.goToPrompt)
-                self.goToPrompt.show()
-                self.goToPrompt.activateWindow()
-        except Exception as e:
-            show_error("Error in upon_process_finishing() in New Genome.", e)
-    #clear the job table
-    def clear_all(self):
-        try:
-            self.process.kill()
-            self.fin_index = 0
-            self.job_Table.clearContents()
-            self.job_Table.setRowCount(0)
-            self.JobsQueue = []
-            self.check_strings = []
-            self.output_browser.clear()
-            self.output_browser.setText("Waiting for program initiation...")
-            self.orgName.clear()
-            self.strainName.clear()
-            self.orgCode.clear()
-            self.selectedFile.clear()
-            self.selectedFile.setPlaceholderText("Selected FASTA/FNA File")
-            self.progressBar.setValue(0)
-            self.first = False
-        except Exception as e:
-            show_error("Error in clear_all() in New Genome.", e)
-    #reset the whole form
-    def reset(self):
-        try:
-            self.orgName.clear()
-            self.strainName.clear()
-            self.orgCode.clear()
-            self.selectedFile.clear()
-            self.selectedFile.setPlaceholderText("Selected FASTA/FNA File")
-            self.output_browser.clear()
-            self.output_browser.setText("Waiting for program initiation...")
-            self.file = ""
-        except Exception as e:
-            show_error("Error in reset() in New Genome.", e)
-    #event handler for user wanting to close the window
-    def closeEvent(self, event):
-        try:
-            # make sure that there are cspr files in the DB
-            file_names = os.listdir(GlobalSettings.CSPR_DB)
-            noCSPRFiles = True
-            for file in file_names:
-                if 'cspr' in file:
-                    noCSPRFiles = False
-                    break
-            if noCSPRFiles == True:
-                if self.exit == False:
-                    msgBox = QtWidgets.QMessageBox()
-                    msgBox.setStyleSheet("font: " + str(self.fontSize) + "pt 'Arial'")
-                    msgBox.setIcon(QtWidgets.QMessageBox.Icon.Question)
-                    msgBox.setWindowTitle("No CSPR file generated")
-                    msgBox.setText("No CSPR file has been generated, thus the main program cannot run. Please create a CSPR file."
-                                                            "Alternatively, you could quit the program. Would you like to quit?")
-                    msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Yes)
-                    msgBox.addButton(QtWidgets.QMessageBox.StandardButton.No)
-                    msgBox.exec()
-                    if (msgBox.result() == QtWidgets.QMessageBox.No):
-                        event.ignore()
-                    else:
-                        event.accept()
-                else:
-                    self.exit = False
-                    event.accept()
-            else:
-                self.process.kill()
-                self.clear_all()
-                self.goToPrompt.hide()
-                GlobalSettings.mainWindow.fill_annotation_dropdown()
-                if GlobalSettings.mainWindow.orgChoice.currentText() != '':
-                    GlobalSettings.mainWindow.orgChoice.currentIndexChanged.disconnect()
-                GlobalSettings.mainWindow.orgChoice.clear()
-                GlobalSettings.mainWindow.endoChoice.clear()
-                GlobalSettings.mainWindow.getData()
-                GlobalSettings.MTWin.launch()
-                GlobalSettings.pop_Analysis.launch()
-                if GlobalSettings.mainWindow.first_show == True:
-                    GlobalSettings.mainWindow.first_show = False
-                    GlobalSettings.mainWindow.centerUI()
-                GlobalSettings.mainWindow.show()
-                event.accept()
-        except Exception as e:
-            show_error("Error in closeEvent() in New Genome.", e)
-    #event handler for user wanting to go to Main once jobs complete
-    def continue_to_main(self):
-        try:
-            # make sure that there are cspr files in the DB
-            file_names = os.listdir(GlobalSettings.CSPR_DB)
-            noCSPRFiles = True
-            for file in file_names:
-                if 'cspr' in file:
-                    noCSPRFiles = False
-                    break
-            if noCSPRFiles == True:
-                msgBox = QtWidgets.QMessageBox()
-                msgBox.setStyleSheet("font: " + str(self.fontSize) + "pt 'Arial'")
-                msgBox.setIcon(QtWidgets.QMessageBox.Icon.Question)
-                msgBox.setWindowTitle("No CSPR file generated")
-                msgBox.setText(
-                    "No CSPR file has been generated, thus the main program cannot run. Please create a CSPR file."
-                    "Alternatively, you could quit the program. Would you like to quit?")
-                msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Yes)
-                msgBox.addButton(QtWidgets.QMessageBox.StandardButton.No)
-                msgBox.exec()
-                if (msgBox.result() == QtWidgets.QMessageBox.Yes):
-                    self.exit = True
-                    self.close()
-            else:
-                self.process.kill()
-                self.clear_all()
-                self.goToPrompt.hide()
-                GlobalSettings.mainWindow.fill_annotation_dropdown()
-                if GlobalSettings.mainWindow.orgChoice.currentText() != '':
-                    GlobalSettings.mainWindow.orgChoice.currentIndexChanged.disconnect()
-                GlobalSettings.mainWindow.orgChoice.clear()
-                GlobalSettings.mainWindow.endoChoice.clear()
-                GlobalSettings.mainWindow.getData()
-                GlobalSettings.MTWin.launch()
-                GlobalSettings.pop_Analysis.launch()
-                # center main on current screen
-                if GlobalSettings.mainWindow.first_show == True:
-                    GlobalSettings.mainWindow.first_show = False
-                    center_ui(GlobalSettings.mainWindow)
-                GlobalSettings.mainWindow.show()
-                self.hide()
-        except Exception as e:
-            show_error("Error in continue_to_main() in New Genome.", e)
-    #event handler for user wanting to go to multi-targeting once jobs complete
-    def continue_to_MT(self):
-        try:
-            # make sure that there are cspr files in the DB
-            file_names = os.listdir(GlobalSettings.CSPR_DB)
-            noCSPRFiles = True
-            for file in file_names:
-                if 'cspr' in file:
-                    noCSPRFiles = False
-                    break
-            if noCSPRFiles == True:
-                msgBox = QtWidgets.QMessageBox()
-                msgBox.setStyleSheet("font: " + str(self.fontSize) + "pt 'Arial'")
-                msgBox.setIcon(QtWidgets.QMessageBox.Icon.Question)
-                msgBox.setWindowTitle("No CSPR file generated")
-                msgBox.setText(
-                    "No CSPR file has been generated, thus the main program cannot run. Please create a CSPR file."
-                    "Alternatively, you could quit the program. Would you like to quit?")
-                msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Yes)
-                msgBox.addButton(QtWidgets.QMessageBox.StandardButton.No)
-                msgBox.exec()
-                if (msgBox.result() == QtWidgets.QMessageBox.Yes):
-                    self.exit = True
-                    self.close()
-            else:
-                self.process.kill()
-                self.clear_all()
-                self.goToPrompt.hide()
-                GlobalSettings.mainWindow.fill_annotation_dropdown()
-                if GlobalSettings.mainWindow.orgChoice.currentText() != '':
-                    GlobalSettings.mainWindow.orgChoice.currentIndexChanged.disconnect()
-                GlobalSettings.mainWindow.orgChoice.clear()
-                GlobalSettings.mainWindow.endoChoice.clear()
-                GlobalSettings.mainWindow.getData()
-                GlobalSettings.MTWin.launch()
-                GlobalSettings.pop_Analysis.launch()
-                # center multi-targeting on current screen
-                if GlobalSettings.MTWin.first_show == True:
-                    GlobalSettings.MTWin.first_show = False
-                    GlobalSettings.MTWin.centerUI()
-                GlobalSettings.MTWin.show()
-                self.hide()
-        except Exception as e:
-            show_error("Error in continue_to_MT() in New Genome.", e)
-    #event handler for user wanting to go to population analysis once jobs complete
-    def continue_to_pop(self):
-        try:
-            # make sure that there are cspr files in the DB
-            file_names = os.listdir(GlobalSettings.CSPR_DB)
-            noCSPRFiles = True
-            for file in file_names:
-                if 'cspr' in file:
-                    noCSPRFiles = False
-                    break
-            if noCSPRFiles == True:
-                msgBox = QtWidgets.QMessageBox()
-                msgBox.setStyleSheet("font: " + str(self.fontSize) + "pt 'Arial'")
-                msgBox.setIcon(QtWidgets.QMessageBox.Icon.Question)
-                msgBox.setWindowTitle("No CSPR file generated")
-                msgBox.setText(
-                    "No CSPR file has been generated, thus the main program cannot run. Please create a CSPR file."
-                    "Alternatively, you could quit the program. Would you like to quit?")
-                msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Yes)
-                msgBox.addButton(QtWidgets.QMessageBox.StandardButton.No)
-                msgBox.exec()
-                if (msgBox.result() == QtWidgets.QMessageBox.Yes):
-                    self.exit = True
-                    self.close()
-            else:
-                self.process.kill()
-                self.clear_all()
-                self.goToPrompt.hide()
-                GlobalSettings.mainWindow.fill_annotation_dropdown()
-                if GlobalSettings.mainWindow.orgChoice.currentText() != '':
-                    GlobalSettings.mainWindow.orgChoice.currentIndexChanged.disconnect()
-                GlobalSettings.mainWindow.orgChoice.clear()
-                GlobalSettings.mainWindow.endoChoice.clear()
-                GlobalSettings.mainWindow.getData()
-                GlobalSettings.MTWin.launch()
-                GlobalSettings.pop_Analysis.launch()
-                if GlobalSettings.pop_Analysis.first_show == True:
-                    GlobalSettings.pop_Analysis.first_show = False
-                    GlobalSettings.pop_Analysis.centerUI()
-                GlobalSettings.pop_Analysis.show()
-                self.hide()
-        except Exception as e:
-            show_error("Error in continue_to_pop() in New Genome.", e)

src/views/PopulationAnalysisWindowView.py CHANGED Viewed

@@ -1,130 +1,138 @@
 from PyQt6 import QtWidgets, uic, QtGui, QtCore
-from PyQt6.QtWidgets import QHeaderView
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg
 from matplotlib.figure import Figure
 import mplcursors
 import numpy as np
 import matplotlib.patches as patches
-from utils.ui import show_error, scale_ui, center_ui
 class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
     def __init__(self, global_settings):
-        super(PopulationAnalysisWindowView, self).__init__()
-        self.global_settings = global_settings
         self.init_ui()
     def init_ui(self):
         try:
-            uic.loadUi(self.global_settings.get_ui_dir() + '/pop.ui', self)
-            self.setWindowIcon(QtGui.QIcon(self.global_settings.get_assets_dir() + "/cas9image.ico"))
-            self.setWindowTitle('Population Analysis')
-            self.setup_tables()
-            self.setup_buttons()
-            self.setup_colormap()
-            self.setup_styles()
-            scale_ui(self, base_width=1920, base_height=1080, font_size=12, header_font_size=30)
         except Exception as e:
-            show_error(self.global_settings, "Error initializing PopulationAnalysisWindowView.", str(e))
-    def setup_tables(self):
-        # Organism table
-        self.org_Table.setColumnCount(1)
-        self.org_Table.setShowGrid(False)
-        self.org_Table.setHorizontalHeaderLabels(["Organism"])
-        self.org_Table.horizontalHeader().setSectionsClickable(True)
-        self.org_Table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
-        self.org_Table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectionBehavior.SelectRows)
-        self.org_Table.setEditTriggers(QtWidgets.QAbstractItemView.EditTrigger.NoEditTriggers)
-        self.org_Table.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.MultiSelection)
-        # Shared seeds table
-        self.table2.setColumnCount(9)
-        self.table2.setShowGrid(False)
-        self.table2.setHorizontalHeaderLabels(["Seed","% Coverage","Total Repeats","Avg. Repeats/Scaffold", "Consensus Sequence", "% Consensus", "Score","PAM", "Strand"])
-        self.table2.horizontalHeader().setSectionsClickable(True)
-        self.table2.setEditTriggers(QtWidgets.QAbstractItemView.EditTrigger.NoEditTriggers)
-        self.table2.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.SizeAdjustPolicy.AdjustToContents)
-        self.table2.setSelectionBehavior(QtWidgets.QTableView.SelectionBehavior.SelectRows)
-        self.table2.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.MultiSelection)
-        self.table2.resizeColumnsToContents()
-        # Location finder table
-        self.loc_finder_table.setColumnCount(5)
-        self.loc_finder_table.setShowGrid(False)
-        self.loc_finder_table.setHorizontalHeaderLabels(["Seed ID", "Sequence", "Organism", "Scaffold", "Location"])
-        self.loc_finder_table.horizontalHeader().setSectionsClickable(True)
-        self.loc_finder_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
-        self.loc_finder_table.setEditTriggers(QtWidgets.QAbstractItemView.EditTrigger.NoEditTriggers)
-        self.loc_finder_table.resizeColumnsToContents()
-    def setup_buttons(self):
-        self.goBackButton.setText("Go Back")
-        self.analyze_button.setText("Analyze")
-        self.clear_Button.setText("Clear")
-        self.export_button.setText("Export")
-        self.find_locs_button.setText("Find Locations")
-        self.clear_loc_button.setText("Clear Locations")
-        self.query_seed_button.setText("Search Seeds")
-    def setup_colormap(self):
-        self.colormap_layout = QtWidgets.QVBoxLayout()
-        self.colormap_layout.setContentsMargins(0, 0, 0, 0)
-        self.colormap_canvas = MplCanvas(self)
-        self.colormap_layout.addWidget(self.colormap_canvas)
-        self.colormap_figure.setLayout(self.colormap_layout)
-    def setup_styles(self):
-        groupbox_style = """
-        QGroupBox:title{subcontrol-origin: margin;
-                        left: 10px;
-                        padding: 0 5px 0 15px;}
-        QGroupBox#groupBox{border: 2px solid rgb(111,181,110);
-                        border-radius: 9px;
-                        font: bold 14pt 'Arial';
-                        margin-top: 10px;}"""
-        self.groupBox.setStyleSheet(groupbox_style)
-        self.groupBox_2.setStyleSheet(groupbox_style.replace("groupBox","groupBox_2"))
     def get_selected_endo(self):
-        return self.endoBox.currentText()
     def get_selected_organisms(self):
         return [index.row() for index in self.org_Table.selectionModel().selectedRows()]
     def get_selected_seeds(self):
-        return [self.table2.item(index.row(), 0).text() for index in self.table2.selectionModel().selectedRows()]
     def get_seed_input(self):
         return self.seed_input.text()
     def get_selected_seeds_for_export(self):
-        return [item.text() for item in self.table2.selectedItems() if item.column() == 0]
     def update_org_table(self, org_data):
-        self.org_Table.setRowCount(len(org_data))
         for row, (org_name, cspr_file, db_file) in enumerate(org_data):
             item = QtWidgets.QTableWidgetItem(org_name)
             item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignVCenter)
-            self.org_Table.setItem(row, 0, item)
-        self.org_Table.resizeColumnsToContents()
     def update_shared_seeds_table(self, seed_data):
-        self.table2.setRowCount(len(seed_data))
         for row, data in enumerate(seed_data):
             for col, value in enumerate(data):
                 item = QtWidgets.QTableWidgetItem(str(value))
                 item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
-                self.table2.setItem(row, col, item)
-        self.table2.resizeColumnsToContents()
     def update_loc_finder_table(self, loc_data):
-        self.loc_finder_table.setRowCount(len(loc_data))
         for row, data in enumerate(loc_data):
             for col, key in enumerate(['seed', 'sequence', 'organism', 'chromosome', 'location']):
                 item = QtWidgets.QTableWidgetItem(str(data[key]))
                 item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
-                self.loc_finder_table.setItem(row, col, item)
-        self.loc_finder_table.resizeColumnsToContents()
     def plot_heatmap(self, data, labels):
         self.colormap_canvas.axes.clear()
@@ -159,28 +167,35 @@ class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
         self.colormap_canvas.draw()
     def clear_shared_seeds_table(self):
-        self.table2.setRowCount(0)
     def clear_loc_finder_table(self):
         self.loc_finder_table.setRowCount(0)
-    def show_loading_window(self, value):
-        self.loading_window.loading_bar.setValue(value)
-        self.loading_window.show()
-    def hide_loading_window(self):
-        self.loading_window.hide()
-    def update_loading_window(self, value, text):
-        self.loading_window.loading_bar.setValue(value)
-        self.loading_window.info_label.setText(text)
     def update_endo_dropdown(self, endos):
-        self.endoBox.clear()
-        self.endoBox.addItems(endos)
     def sort_table2(self, column):
-        self.table2.sortItems(column)
     def sort_loc_finder_table(self, column):
         self.loc_finder_table.sortItems(column)
@@ -194,12 +209,3 @@ class MplCanvas(FigureCanvasQTAgg):
             super(MplCanvas, self).__init__(fig)
         except Exception as e:
             show_error("Error initializing MplCanvas class in population analysis.", e)
-class LoadingWindow(QtWidgets.QMainWindow):
-    def __init__(self, global_settings):
-        super(LoadingWindow, self).__init__()
-        uic.loadUi(global_settings.get_ui_dir() + "/loading_data_form.ui", self)
-        self.loading_bar.setValue(0)
-        self.setWindowTitle("Loading Data")
-        self.setWindowIcon(QtGui.QIcon(global_settings.get_assets_dir() + "cas9image.ico"))
-        scale_ui(self, base_width=1920, base_height=1080, font_size=12, header_font_size=30, custom_scale_width=450, custom_scale_height=125)

 from PyQt6 import QtWidgets, uic, QtGui, QtCore
+from PyQt6.QtWidgets import QHeaderView, QAbstractItemView
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg
 from matplotlib.figure import Figure
 import mplcursors
 import numpy as np
 import matplotlib.patches as patches
+from utils.ui import show_error, scale_ui
 class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
     def __init__(self, global_settings):
+        super().__init__()
+        self.settings = global_settings
+        self.logger = self.settings.get_logger()
         self.init_ui()
     def init_ui(self):
         try:
+            uic.loadUi(self.settings.get_ui_dir_path() + '/population_analysis.ui', self)
+            self._init_ui_components()
         except Exception as e:
+            show_error(self.settings, "Error initializing PopulationAnalysisWindowView", str(e))
+    def _init_ui_components(self):
+        self._init_grpSelectOrganisms()
+        self._init_grpSeedAnalysis()
+        # self._init_colormap()
+    def _init_grpSelectOrganisms(self):
+        self.combo_box_endonuclease = self._find_widget('cmbEndonuclease', QtWidgets.QComboBox)
+        print(self.combo_box_endonuclease)
+        self.table_organism = self._find_widget('tblOrganism', QtWidgets.QTableWidget)
+        self.push_button_analyze_organism = self._find_widget('pbtnAnalyzeOrganism', QtWidgets.QPushButton)
+        self.tab_widget_shared_seeds_heatmap = self._find_widget('tabsSharedSeedHeatmap', QtWidgets.QTabWidget)
+        self.tab_shared_seed_heatmap = self._find_widget('tabSharedSeedHeatmap', QtWidgets.QWidget)
+        self.heatmap_seed = self._find_widget('heatmapSeed', QtWidgets.QWidget)
+        self.table_organism.setColumnCount(1)
+        self.table_organism.setShowGrid(False)
+        self.table_organism.setHorizontalHeaderLabels(["Organism"])
+        self.table_organism.horizontalHeader().setSectionsClickable(True)
+        self.table_organism.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
+        self.table_organism.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.table_organism.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.table_organism.setSelectionMode(QAbstractItemView.SelectionMode.MultiSelection)
+    def _init_grpSeedAnalysis(self):
+        self.line_edit_seed = self._find_widget('ledSeed', QtWidgets.QLineEdit)
+        self.push_button_query_seed = self._find_widget('pbtnQuerySeed', QtWidgets.QPushButton)
+        self.push_button_clear_seeds = self._find_widget('pbtnClearSeeds', QtWidgets.QPushButton)
+        self.table_seed = self._find_widget('tblSeed', QtWidgets.QTableWidget)
+        self.table_seed.setColumnCount(9)
+        self.table_seed.setShowGrid(False)
+        self.table_seed.setHorizontalHeaderLabels([
+            "Seed", "% Coverage", "Total Repeats", "Avg. Repeats/Scaffold",
+            "Consensus Sequence", "% Consensus", "Score", "PAM", "Strand"
+        ])
+        self.table_seed.horizontalHeader().setSectionsClickable(True)
+        self.table_seed.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.table_seed.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.table_seed.setSelectionMode(QAbstractItemView.SelectionMode.MultiSelection)
+        self.push_button_find_locations = self._find_widget('pbtnFindLocations', QtWidgets.QPushButton)
+        self.push_button_clear_locations = self._find_widget('pbtnClearLocations', QtWidgets.QPushButton)
+        self.table_locations = self._find_widget('tblLocation', QtWidgets.QTableWidget)
+        self.table_locations.setColumnCount(5)
+        self.table_locations.setShowGrid(False)
+        self.table_locations.setHorizontalHeaderLabels([
+                "Seed ID", "Sequence", "Organism", "Scaffold", "Location"
+        ])
+        self.table_locations.horizontalHeader().setSectionsClickable(True)
+        self.table_locations.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
+        self.table_locations.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+    # def _init_colormap(self):
+    #     self.colormap_figure = self._find_widget('wgtColormap', QtWidgets.QWidget)
+    #     if self.colormap_figure:
+    #         self.colormap_layout = QtWidgets.QVBoxLayout()
+    #         self.colormap_layout.setContentsMargins(0, 0, 0, 0)
+    #         self.colormap_canvas = MplCanvas(self)
+    #         self.colormap_layout.addWidget(self.colormap_canvas)
+    #         self.colormap_figure.setLayout(self.colormap_layout)
+    def _find_widget(self, name: str, widget_type: type) -> QtWidgets.QWidget:
+        widget = self.findChild(widget_type, name)
+        if widget is None:
+            self.logger.warning(f"Widget '{name}' not found in UI file.")
+        return widget
     def get_selected_endo(self):
+        return self.combo_box_endonuclease.currentText()
     def get_selected_organisms(self):
         return [index.row() for index in self.org_Table.selectionModel().selectedRows()]
     def get_selected_seeds(self):
+        return [self.table_seed.item(index.row(), 0).text() for index in self.table_seed.selectionModel().selectedRows()]
     def get_seed_input(self):
         return self.seed_input.text()
     def get_selected_seeds_for_export(self):
+        return [item.text() for item in self.table_seed.selectedItems() if item.column() == 0]
     def update_org_table(self, org_data):
+        self.table_organism.setRowCount(len(org_data))
         for row, (org_name, cspr_file, db_file) in enumerate(org_data):
             item = QtWidgets.QTableWidgetItem(org_name)
             item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignVCenter)
+            self.table_organism.setItem(row, 0, item)
+        self.table_organism.resizeColumnsToContents()
     def update_shared_seeds_table(self, seed_data):
+        self.table_seed.setRowCount(len(seed_data))
         for row, data in enumerate(seed_data):
+            print(data)
             for col, value in enumerate(data):
                 item = QtWidgets.QTableWidgetItem(str(value))
                 item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+                self.table_seed.setItem(row, col, item)
+        self.table_seed.resizeColumnsToContents()
     def update_loc_finder_table(self, loc_data):
+        self.table_locations.setRowCount(len(loc_data))
         for row, data in enumerate(loc_data):
+            print(data)
             for col, key in enumerate(['seed', 'sequence', 'organism', 'chromosome', 'location']):
                 item = QtWidgets.QTableWidgetItem(str(data[key]))
                 item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+                self.table_locations.setItem(row, col, item)
+        self.table_locations.resizeColumnsToContents()
     def plot_heatmap(self, data, labels):
         self.colormap_canvas.axes.clear()
         self.colormap_canvas.draw()
     def clear_shared_seeds_table(self):
+        self.table_seed.setRowCount(0)
     def clear_loc_finder_table(self):
         self.loc_finder_table.setRowCount(0)
     def update_endo_dropdown(self, endos):
+        """Update the endonuclease dropdown with the provided options"""
+        try:
+            self.logger.info("Starting update_endo_dropdown")
+            self.logger.debug(f"Received endos: {endos}")
+            print(self.combo_box_endonuclease)
+            # if not self.combo_box_endonuclease:
+                # self.logger.error("combo_box_endonuclease is None")
+                # return
+            self.combo_box_endonuclease.clear()
+            self.combo_box_endonuclease.addItems(endos)
+            self.logger.info(f"Updated endonuclease dropdown with {len(endos)} options")
+            self.logger.debug(f"Current items in dropdown: {[self.combo_box_endonuclease.itemText(i) for i in range(self.combo_box_endonuclease.count())]}")
+        except Exception as e:
+            self.logger.error(f"Error updating endonuclease dropdown: {str(e)}")
+            self.logger.exception("Full traceback:")
+            show_error(self.settings, "Error updating endonuclease dropdown", str(e))
     def sort_table2(self, column):
+        self.table_seed.sortItems(column)
     def sort_loc_finder_table(self, column):
         self.loc_finder_table.sortItems(column)
             super(MplCanvas, self).__init__(fig)
         except Exception as e:
             show_error("Error initializing MplCanvas class in population analysis.", e)

src/views/ViewTargetsView.py CHANGED Viewed

@@ -61,24 +61,63 @@ class ViewTargetsView(QtWidgets.QMainWindow):
         return widget
     def display_targets_in_table(self, targets):
         self.table_targets.setRowCount(len(targets))
         for row, target in enumerate(targets):
-            self.table_targets.setItem(row, 0, QTableWidgetItem(str(target[0])))  # Location
-            self.table_targets.setItem(row, 1, QTableWidgetItem(target[5]))  # Endonuclease
-            self.table_targets.setItem(row, 2, QTableWidgetItem(target[1]))  # Sequence
-            self.table_targets.setItem(row, 3, QTableWidgetItem(target[4]))  # Strand
-            self.table_targets.setItem(row, 4, QTableWidgetItem(target[2]))  # PAM
-            self.table_targets.setItem(row, 5, QTableWidgetItem(str(target[3])))  # Score
-            self.table_targets.setItem(row, 6, QTableWidgetItem("N/A"))  # Off-Target (placeholder)
             details_button = QtWidgets.QPushButton("Details")
             self.table_targets.setCellWidget(row, 7, details_button)
         self.table_targets.resizeColumnsToContents()
     def get_selected_targets(self):
         selected_rows = set(index.row() for index in self.table_targets.selectedIndexes())
-        return [self.get_row_data(row) for row in selected_rows]
     def get_row_data(self, row):
         return {

         return widget
     def display_targets_in_table(self, targets):
+        """Display targets in table with all data"""
         self.table_targets.setRowCount(len(targets))
         for row, target in enumerate(targets):
+            # Handle tuple format (location, sequence, pam, score, strand, endonuclease)
+            if isinstance(target, tuple):
+                self.table_targets.setItem(row, 0, QTableWidgetItem(str(target[0])))  # Location
+                self.table_targets.setItem(row, 1, QTableWidgetItem(str(target[5])))  # Endonuclease
+                self.table_targets.setItem(row, 2, QTableWidgetItem(str(target[1])))  # Sequence
+                self.table_targets.setItem(row, 3, QTableWidgetItem(str(target[4])))  # Strand
+                self.table_targets.setItem(row, 4, QTableWidgetItem(str(target[2])))  # PAM
+                self.table_targets.setItem(row, 5, QTableWidgetItem(str(target[3])))  # Score
+                self.table_targets.setItem(row, 6, QTableWidgetItem("--.--"))  # Off-Target placeholder
+            # Handle dictionary format
+            else:
+                self.table_targets.setItem(row, 0, QTableWidgetItem(str(target['location'])))
+                self.table_targets.setItem(row, 1, QTableWidgetItem(str(target['endonuclease'])))
+                self.table_targets.setItem(row, 2, QTableWidgetItem(str(target['sequence'])))
+                self.table_targets.setItem(row, 3, QTableWidgetItem(str(target['strand'])))
+                self.table_targets.setItem(row, 4, QTableWidgetItem(str(target['pam'])))
+                self.table_targets.setItem(row, 5, QTableWidgetItem(str(target['score'])))
+                self.table_targets.setItem(row, 6, QTableWidgetItem("--.--"))
+            # Add details button
             details_button = QtWidgets.QPushButton("Details")
             self.table_targets.setCellWidget(row, 7, details_button)
         self.table_targets.resizeColumnsToContents()
     def get_selected_targets(self):
+        """Get selected targets with all necessary data"""
         selected_rows = set(index.row() for index in self.table_targets.selectedIndexes())
+        selected_targets = []
+        # Get column indices once
+        columns = {
+            'location': 0,
+            'endonuclease': 1,
+            'sequence': 2,  # Make sure to get the sequence
+            'strand': 3,
+            'pam': 4,
+            'score': 5,
+            'off_target': 6
+        }
+        for row in selected_rows:
+            target = {
+                'location': self.table_targets.item(row, columns['location']).text(),
+                'endonuclease': self.table_targets.item(row, columns['endonuclease']).text(),
+                'sequence': self.table_targets.item(row, columns['sequence']).text(),  # Get sequence
+                'strand': self.table_targets.item(row, columns['strand']).text(),
+                'pam': self.table_targets.item(row, columns['pam']).text(),
+                'score': self.table_targets.item(row, columns['score']).text(),
+                'off_target': self.table_targets.item(row, columns['off_target']).text()
+            }
+            selected_targets.append(target)
+        return selected_targets
     def get_row_data(self, row):
         return {

src/views/closingWin.py DELETED Viewed

@@ -1,73 +0,0 @@
-import models.GlobalSettings as GlobalSettings
-import os
-from PyQt5 import QtWidgets, Qt, uic
-import traceback
-import math
-from utils.ui import show_error, scale_ui
-logger = GlobalSettings.logger
-###########################################################
-# closingWindow: this class is a little window where the user can select which files they want to delete
-# Once they hit 'submit' it will delete all of the files selected, and close the program.
-# If no files are selected, the program closes and no files are deleted
-# Inputs are taking from the user (selecting files to delete and hitting submit), as well as GlobalSettings for the files in CSPR_DB
-# Outputs are the files are deleting, and the program is closed
-###########################################################
-class closingWindow(QtWidgets.QMainWindow):
-    def __init__(self):
-        try:
-            super(closingWindow, self).__init__()
-            uic.loadUi(GlobalSettings.appdir + "ui/closing_window.ui", self)
-            self.setWindowTitle("Delete Files")
-            self.setWindowIcon(Qt.QIcon(GlobalSettings.appdir + "cas9image.ico"))
-            # Button
-            self.submit_button.clicked.connect(self.submit_and_close)
-            # Table
-            self.files_table.setColumnCount(1)
-            self.files_table.setShowGrid(True)
-            self.files_table.setHorizontalHeaderLabels("File Name;".split(";"))
-            self.files_table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
-            self.files_table.setEditTriggers(QtWidgets.QAbstractItemView.NoEditTriggers)
-            self.files_table.setSelectionMode(QtWidgets.QAbstractItemView.MultiSelection)
-            scale_ui(self, custom_scale_width=400, custom_scale_height=300)
-        except Exception as e:
-            show_error("Error initializing closingWindow class.", e)
-    # this function will delete selected files, and then close the program
-    def submit_and_close(self):
-        try:
-            # loop through the whole table
-            for i in range(self.files_table.rowCount()):
-                tabWidget = self.files_table.item(i, 0)
-                # if that specific tab is selected, delete it. otherwise do nothing
-                if tabWidget.isSelected():
-                    os.remove(tabWidget.text())
-            self.close()
-        except Exception as e:
-            show_error("Error in sumbit_and_close() in closing window.", e)
-    # this function gets all of the files from the CSPR_DB and puts them all into the table
-    def get_files(self):
-        try:
-            loopCount = 0
-            # get the file names from CSPR_DB
-            files_names = os.listdir(GlobalSettings.CSPR_DB)
-            files_names.sort(key=str.lower)
-            self.files_table.setRowCount(len(files_names))
-            # loop through and add them to the table
-            for file in files_names:
-                tabWidget = QtWidgets.QTableWidgetItem(file)
-                self.files_table.setItem(loopCount, 0, tabWidget)
-                loopCount += 1
-            self.files_table.resizeColumnsToContents()
-        except Exception as e:
-            show_error("Error in get_files() in closing window.", e)

src/views/export_tool.py DELETED Viewed

@@ -1,259 +0,0 @@
-import models.GlobalSettings as GlobalSettings
-from utils.sequence_utils import get_table_headers
-import os
-from PyQt5 import QtWidgets, Qt, uic, QtCore, QtGui
-import platform
-import traceback
-import math
-from utils.ui import show_message, show_error, scale_ui, center_ui
-logger = GlobalSettings.logger
-# This class opens a window for the user to select where they want the CSV file exported to, and the name of the file
-# It takes the highlighted data from the Results page, and creates a CSV file from that
-class export_tool(QtWidgets.QMainWindow):
-    def __init__(self):
-        try:
-            super(export_tool, self).__init__()
-            uic.loadUi(GlobalSettings.appdir + 'ui/export_tool.ui', self)
-            self.setWindowIcon(Qt.QIcon(GlobalSettings.appdir + "cas9image.ico"))
-            self.browse_button.clicked.connect(self.browseForFolder)
-            self.cancel_button.clicked.connect(self.cancel_function)
-            self.export_button.clicked.connect(self.export_function)
-            # Set up validators for input fields:
-            reg_ex = QtCore.QRegExp("[^,]+") # No commas
-            input_validator = QtGui.QRegExpValidator(reg_ex, self)
-            self.leading_seq.setValidator(input_validator)
-            self.trailing_seq.setValidator(input_validator)
-            # GroupBox styling
-            groupbox_style = """
-            QGroupBox:title{subcontrol-origin: margin;
-                            left: 10px;
-                            padding: 0 5px 0 5px;}
-            QGroupBox#gRNA_Options{border: 2px solid rgb(111,181,110);
-                            border-radius: 9px;
-                            margin-top: 10px;
-                            font: bold 14pt 'Arial';} """
-            self.gRNA_Options.setStyleSheet(groupbox_style)
-            self.location = self.fileLocation_line_edit.text()
-            self.selected_table_items = []
-            self.window = ""
-            self.num_columns = []
-            self.locus_tag = False
-            self.gene_name = False
-            self.setWindowTitle("Export to CSV")
-            scale_ui(self, custom_scale_width=650, custom_scale_height=200)
-        except Exception as e:
-            show_error("Error initializing export_tool class.", e)
-    # launch function. Called in Results.
-    # parameter expect: a list of the items selected from the window.
-    def launch(self, select_items, window):
-        try:
-            if platform.system() == "Windows":
-                self.fileLocation_line_edit.setText(GlobalSettings.CSPR_DB + "\\")
-            else:
-                self.fileLocation_line_edit.setText(GlobalSettings.CSPR_DB + "/")
-            self.selected_table_items = select_items
-            self.window = window
-            center_ui(self)
-            self.show()
-            self.activateWindow()
-        except Exception as e:
-            show_error("Error in launch() in export_tool.", e)
-    # Takes the path and file name and combines them
-    # Writes the header line, as well as ever line selected to that file
-    # calls the cancel function when it's done
-    def export_function(self):
-        try:
-            delim = self.delimBox.currentText()
-            # get the full path ( path and file name)
-            file_name = self.filename_line_edit.text()
-            if file_name == "":
-                file_name = "exported_gRNAs"
-                self.location = self.fileLocation_line_edit.text()
-            full_path = ""
-            if '.' in file_name: # If user added the file extension...
-                full_path = self.location + file_name
-            else:
-                if delim == ",":
-                    full_path = self.location + file_name + '.csv'
-                elif delim == r"\t":
-                    delim = "\t"
-                    full_path = self.location + file_name + '.tsv'
-                else:
-                    full_path = self.location + file_name + '.txt'
-            try:
-                output_data = open(full_path, 'w')
-                """ Write the table headers """
-                if self.window == "mt": ###Change headers for multitargeting table export
-                    headers = get_table_headers(GlobalSettings.MTWin.table)
-                    num_cols = len(headers) # Calculate the number of columns based on the headers list above
-                    insertion_index = headers.index("% Consensus")
-                    headers.insert(insertion_index, "Full Sequence")
-                    output_data.write(delim.join(headers)+"\n")
-                elif self.window == "pa":
-                    headers = get_table_headers(GlobalSettings.pop_Analysis.table2)
-                    num_cols = len(headers) # Calculate the number of columns based on the headers list above
-                    insertion_index = headers.index("% Consensus")
-                    headers.insert(insertion_index, "Full Sequence")
-                    output_data.write(delim.join(headers)+"\n")
-                else: ###Change headers for view results export
-                    headers = get_table_headers(GlobalSettings.mainWindow.Results.targetTable)
-                    headers.remove("Details") # For some reason, the details column doesn't carry any "items"
-                    num_cols = len(headers) # Calculate the number of columns based on the headers list above
-                    insertion_index = headers.index("Strand")
-                    headers.insert(insertion_index, "Full Sequence")
-                    if GlobalSettings.mainWindow.radioButton_Gene.isChecked(): # If the user chose to search via Feature
-                        tmp = GlobalSettings.mainWindow.Results.comboBoxGene.currentText().split(":") # Check to see if the locus tag was found for the current gene
-                        if len(tmp) > 1: # If locus tag exists for gene, include in output
-                            headers.extend(["Locus_Tag","Gene_Name"])
-                            output_data.write(delim.join(headers)+"\n")
-                            self.locus_tag = True
-                            self.gene_name = True
-                        else: # If locus tag does not exist for gene, only include the gene name
-                            headers.append("Gene_Name")
-                            output_data.write(delim.join(headers)+"\n")
-                            self.gene_name = True
-                            self.locus_tag = False
-                    else: # If user searched by sequence or position, don't include locus tag or gene name
-                        output_data.write(delim.join(headers)+"\n")
-                        self.gene_name = False
-                        self.locus_tag = False
-                """ Write the data out """
-                tmp_list = []
-                if self.locus_tag: #If the user is exporting data from VT and locus tag exists for current gene
-                    tmp = GlobalSettings.mainWindow.Results.comboBoxGene.currentText().split(":") # Get the locus tag
-                    locus_tag = str(tmp[0].strip())
-                    gene_name = str(tmp[-1].strip())
-                    seq_index = headers.index("Sequence")                    # Get the gene name
-                    it = 0
-                    for i, item in enumerate(self.selected_table_items): # Loop through all the items in the View Targets table
-                        if (i+1) % num_cols == 0:
-                            tmp_list.append(item.text())
-                            tmp_list.append(locus_tag)
-                            tmp_list.append(gene_name)
-                            output_data.write(delim.join(tmp_list)+"\n") # Write data out
-                            tmp_list.clear() # Reset list
-                            it = 0 # Reset iterator
-                        elif it == seq_index:
-                            tmp_list.append(item.text())
-                            tmp_list.append(self.leading_seq.text().strip() + item.text() + self.trailing_seq.text().strip()) #5' Leader + gRNA + 3' Trailer
-                            it += 1
-                        else:
-                            tmp_list.append(item.text())
-                            it += 1
-                elif self.gene_name: #If the user is exporting data from VT and locus tag doesn't exist for current gene
-                    gene_name = str(GlobalSettings.mainWindow.Results.comboBoxGene.currentText().strip()) # Get the locus tag
-                    seq_index = headers.index("Sequence")                    # Get the gene name
-                    it = 0
-                    for i, item in enumerate(self.selected_table_items): # Loop through all the items in the View Targets table
-                        if (i+1) % num_cols == 0:
-                            tmp_list.append(item.text())
-                            tmp_list.append(gene_name)
-                            output_data.write(delim.join(tmp_list)+"\n")
-                            tmp_list.clear()
-                            it = 0 # Reset iterator
-                        elif it == seq_index:
-                            tmp_list.append(item.text())
-                            tmp_list.append(self.leading_seq.text().strip() + item.text() + self.trailing_seq.text().strip()) #5' Leader + gRNA + 3' Trailer
-                            it += 1
-                        else:
-                            tmp_list.append(item.text())
-                            it += 1
-                elif self.window in ["mt", "pa"]: #If the user is exporting data from multitargeting
-                    seq_index = headers.index("Consensus Sequence")
-                    it = 0
-                    for i, item in enumerate(self.selected_table_items): # Loop through all the items in the View Targets table
-                        if (i+1) % num_cols == 0:
-                            tmp_list.append(item.text())
-                            output_data.write(str(delim.join(tmp_list))+"\n")
-                            tmp_list.clear()
-                            it = 0 # Reset iterator
-                        elif it == seq_index:
-                            tmp_list.append(item.text())
-                            tmp_list.append(self.leading_seq.text().strip() + item.text() + self.trailing_seq.text().strip()) #5' Leader + gRNA + 3' Trailer
-                            it += 1
-                        else:
-                            tmp_list.append(item.text())
-                            it += 1
-                else: #If the user is exporting data from View Targets but is not using Feature search
-                    seq_index = headers.index("Sequence")                    # Get the gene name
-                    it = 0
-                    for i, item in enumerate(self.selected_table_items): # Loop through all the items in the View Targets table
-                        if (i+1) % num_cols == 0:
-                            tmp_list.append(item.text())
-                            output_data.write(delim.join(tmp_list)+"\n")
-                            tmp_list.clear()
-                            it = 0 # Reset iterator
-                        elif it == seq_index:
-                            tmp_list.append(item.text())
-                            tmp_list.append(self.leading_seq.text().strip() + item.text() + self.trailing_seq.text().strip()) #5' Leader + gRNA + 3' Trailer
-                            it += 1
-                        else:
-                            tmp_list.append(item.text())
-                            it += 1
-                output_data.close()
-            except PermissionError:
-                show_error("This file cannot be opened. Please make sure that the file is not opened elsewhere and try again.", e)
-                return
-            except Exception as e:
-                show_error("Error in export_function() in export_tool.", e)
-                return
-            """ Print "finished" message """
-            show_message(
-                fontSize=12,
-                icon=QtWidgets.QMessageBox.Icon.Information,
-                title="Export Complete",
-                message=f"Export to {full_path} was successful."
-            )
-            # close the window
-            self.cancel_function()
-        except Exception as e:
-            show_error("Error in export_function() in export_tool.", e)
-    # Resets everything to the init funciton
-    # then closes the window
-    def cancel_function(self):
-        try:
-            if platform.system() == "Windows":
-                self.fileLocation_line_edit.setText(GlobalSettings.CSPR_DB + "\\")
-            else:
-                self.fileLocation_line_edit.setText(GlobalSettings.CSPR_DB + "/")
-            self.filename_line_edit.setText("")
-            self.location = ""
-            self.hide()
-        except Exception as e:
-            show_error("Error in cancel_function() in export_tool.", e)
-    # browse for folder function
-    # allows user to browse for a folder where to store the CSV file
-    def browseForFolder(self):
-        try:
-            # get the folder
-            filed = QtWidgets.QFileDialog()
-            mydir = QtWidgets.QFileDialog.getExistingDirectory(filed, "Open a Folder",
-                                                           GlobalSettings.CSPR_DB, QtWidgets.QFileDialog.ShowDirsOnly)
-            if(os.path.isdir(mydir) == False):
-                return
-            if platform.system() == "Windows":
-                self.fileLocation_line_edit.setText(mydir + "\\")
-                self.location = mydir + "\\"
-            else:
-                self.fileLocation_line_edit.setText(mydir + "/")
-                self.location = mydir + "/"
-        except Exception as e:
-            show_error("Error in browseForFolder() in export_tool.", e)

src/views/generateLib.py DELETED Viewed

@@ -1,662 +0,0 @@
-import models.GlobalSettings as GlobalSettings
-import os
-from PyQt5 import QtWidgets, Qt, uic, QtCore
-from functools import partial
-from models.CSPRparser import CSPRparser
-import re
-import platform
-import traceback
-import math
-from utils.ui import show_message, show_error, scale_ui, center_ui
-from views.annotation_functions import *
-logger = GlobalSettings.logger
-# this class is a window that allows the user to select the settings for Generate Library
-# When the user clicks Generate Library, it goes ahead and gets the Annotation Data needed
-#   Then the user can select the settings they want, and then hit submit.
-#   It creates a txt file with the data
-class genLibrary(QtWidgets.QMainWindow):
-    def __init__(self):
-        try:
-            super(genLibrary, self).__init__()
-            uic.loadUi(GlobalSettings.appdir + 'ui/generate_library.ui', self)
-            self.setWindowTitle('Generate Library')
-            self.setWindowIcon(Qt.QIcon(GlobalSettings.appdir + 'cas9image.ico'))
-            groupbox_style = """
-            QGroupBox:title{subcontrol-origin: margin;
-                            left: 10px;
-                            padding: 0 5px 0 5px;}
-            QGroupBox#Step1{border: 2px solid rgb(111,181,110);
-                            border-radius: 9px;
-                            font: bold 14pt 'Arial';
-                            margin-top: 10px;}"""
-            self.Step1.setStyleSheet(groupbox_style)
-            self.Step2.setStyleSheet(groupbox_style.replace("Step1", "Step2"))
-            self.Step3.setStyleSheet(groupbox_style.replace("Step1", "Step3"))
-            self.Step4.setStyleSheet(groupbox_style.replace("Step1", "Step4"))
-            self.cancel_button.clicked.connect(self.cancel_function)
-            self.BrowseButton.clicked.connect(self.browse_function)
-            self.submit_button.clicked.connect(self.submit_data)
-            self.progressBar.setValue(0)
-            self.anno_data = dict()
-            self.kegg_nonKegg = ''
-            self.gen_lib_dict = dict()
-            self.cspr_data = dict()
-            self.Output = dict()
-            self.off_tol = .05
-            self.off_max_misMatch = 4
-            self.off_target_running = False
-            self.parser = CSPRparser("")
-            # set the numbers for the num genes combo box item
-            for i in range(10):
-                self.numGenescomboBox.addItem(str(i + 1))
-            # set the numbers for the minOn combo box
-            for i in range(19, 70):
-                self.minON_comboBox.addItem(str(i + 1))
-            scale_ui(self, custom_scale_width=950, custom_scale_height=500)
-        except Exception as e:
-            show_error("Error initializing generate library class.", e)
-    # this function launches the window
-    # Parameters:
-    #       annotation_data: a dictionary that has the data for the annotations searched for
-    #           currently MainWindow's searches dict is passed into this
-    #       org_file: the cspr_file that pertains to the organism that user is using at the time
-    #       anno_type: whether the user is using KEGG or another type of annotation file
-    def launch(self, annotation_data, org_file, anno_type):
-        try:
-            self.cspr_file = org_file
-            self.db_file = org_file[:org_file.find('.')] + '_repeats.db'
-            self.anno_data = annotation_data
-            self.kegg_nonKegg = anno_type
-            self.process = QtCore.QProcess()
-            self.parser.fileName = org_file
-            # setting the path and file name fields
-            index1 = self.cspr_file.find('.')
-            if platform.system() == "Windows":
-                index2 = self.cspr_file.rfind('\\')
-            else:
-                index2 = self.cspr_file.rfind('/')
-            self.filename_input.setText(self.cspr_file[index2 + 1:index1] + '_lib')
-            if platform.system() == "Windows":
-                self.output_path.setText(GlobalSettings.CSPR_DB + "\\")
-            else:
-                self.output_path.setText(GlobalSettings.CSPR_DB + "/")
-            # depending on the type of file, build the dictionary accordingly
-            self.build_dict_non_kegg()
-            # get the gRNA data from the cspr file
-            self.cspr_data = self.parser.gen_lib_parser(self.gen_lib_dict, GlobalSettings.mainWindow.endoChoice.currentText())
-            self.get_endo_data()
-            center_ui(self)
-            self.show()
-            self.activateWindow()
-        except Exception as e:
-            show_error("Error in launch() in generate library.", e)
-    def get_endo_data(self):
-        try:
-            f = open(GlobalSettings.appdir + "CASPERinfo")
-            self.endo_data = {}
-            while True:
-                line = f.readline()
-                if line.startswith('ENDONUCLEASES'):
-                    while True:
-                        line = f.readline()
-                        line = line.replace("\n","")
-                        if (line[0] == "-"):
-                            break
-                        line_tokened = line.split(";")
-                        if len(line_tokened) == 10:
-                            endo = line_tokened[0]
-                            five_length = line_tokened[2]
-                            seed_length = line_tokened[3]
-                            three_length = line_tokened[4]
-                            prime = line_tokened[5]
-                            hsu = line_tokened[9]
-                            self.endo_data[endo] = [int(five_length) + int(three_length) + int(seed_length), prime, "MATRIX:" + hsu]
-                    break
-            f.close()
-        except Exception as e:
-            show_error("Error in get_endo_data() in generate library.", e)
-    # this is here in case the user clicks 'x' instead of cancel. Just calls the cancel function
-    def closeEvent(self, event):
-        try:
-            closeWindow = self.cancel_function()
-            # if the user is doing OT and does not decide to cancel it ignore the event
-            if closeWindow == -2:
-                event.ignore()
-            else:
-                event.accept()
-        except Exception as e:
-            show_error("Error in closeEvent() in generate library.", e)
-    # this function takes all of the cspr data and compresses it again for off-target usage
-    def compress_file_off(self):
-        try:
-            if platform.system() == "Windows":
-                file = GlobalSettings.CSPR_DB + "\\off_input.txt"
-            else:
-                file = GlobalSettings.CSPR_DB + "/off_input.txt"
-            f = open(file, 'w')
-            for gene in self.cspr_data:
-                for j in range(len(self.cspr_data[gene])):
-                    loc = self.cspr_data[gene][j][0]
-                    seq = self.cspr_data[gene][j][1]
-                    pam = self.cspr_data[gene][j][2]
-                    score = self.cspr_data[gene][j][3]
-                    strand = self.cspr_data[gene][j][4]
-                    output = str(loc) + ';' + str(seq) + ';' + str(pam) + ';' + str(score) + ';' + str(strand)
-                    f.write(output + '\n')
-            f.close()
-        except Exception as e:
-            show_error("Error in compress_file_off() in generate library.", e)
-    # this function parses the temp_off file, which holds the off-target analysis results
-    # it also updates each target in the cspr_data dictionary to replace the endo with the target's results in off-target
-    def parse_off_file(self):
-        try:
-            if platform.system() == "Windows":
-                file = GlobalSettings.CSPR_DB + "\\temp_off.txt"
-            else:
-                file = GlobalSettings.CSPR_DB + "/temp_off.txt"
-            f = open(file, "r")
-            file_data = f.read().split('\n')
-            f.close()
-            scoreDict = dict()
-            # get the data from the file
-            for i in range(len(file_data)):
-                if file_data[i] == 'AVG OUTPUT':
-                    continue
-                elif file_data[i] != '':
-                    buffer = file_data[i].split(':')
-                    scoreDict[buffer[0]] = buffer[1]
-            # update cspr_Data
-            for gene in self.cspr_data:
-                for i in range(len(self.cspr_data[gene])):
-                    tempTuple = (self.cspr_data[gene][i][0], self.cspr_data[gene][i][1], self.cspr_data[gene][i][2], self.cspr_data[gene][i][3], self.cspr_data[gene][i][4], scoreDict[self.cspr_data[gene][i][1]])
-                    self.cspr_data[gene][i] = tempTuple
-        except Exception as e:
-            show_error("Error in parse_off_file() in generate library.", e)
-    # this function runs the off_target command
-    # NOTE: some changes may be needed to get it to work with other OS besides windows
-    def get_offTarget_data(self, num_targets, minScore, spaceValue, output_file, fiveseq):
-        try:
-            self.perc = False
-            self.bool_temp = False
-            self.running = False
-            # when finished, parse the off file, and then generate the lib
-            def finished():
-                if self.off_target_running:
-                    self.progressBar.setValue(100)
-                    self.parse_off_file()
-                    did_work = self.generate(num_targets, minScore, spaceValue, output_file, fiveseq)
-                    self.off_target_running = False
-                    #self.process.kill()
-                    if did_work != -1:
-                        self.cancel_function()
-                        show_message(
-                            fontSize=12,
-                            icon=QtWidgets.QMessageBox.Icon.Information,
-                            title="Library Generated!",
-                            message="CASPER has finished generating your library!"
-                        )
-                        os.remove(GlobalSettings.CSPR_DB + '/off_input.txt')
-                        os.remove(GlobalSettings.CSPR_DB + '/temp_off.txt')
-            # as off-targeting outputs things, update the off-target progress bar
-            def progUpdate(p):
-                line = str(self.process.readAllStandardOutput())
-                line = line[2:]
-                line = line[:len(line) - 1]
-                if platform.system() == 'Windows':
-                    for lines in filter(None, line.split(r'\r\n')):
-                        if (lines.find("Running Off Target Algorithm for") != -1 and self.perc == False):
-                            self.perc = True
-                        if (self.perc == True and self.bool_temp == False and lines.find(
-                                "Running Off Target Algorithm for") == -1):
-                            lines = lines[32:]
-                            lines = lines.replace("%", "")
-                            if (float(lines) <= 99.5):
-                                num = float(lines)
-                                self.progressBar.setValue(num)
-                            else:
-                                self.bool_temp = True
-                else:
-                    for lines in filter(None, line.split(r'\n')):
-                        if (lines.find("Running Off Target Algorithm for") != -1 and self.perc == False):
-                            self.perc = True
-                        if (self.perc == True and self.bool_temp == False and lines.find(
-                                "Running Off Target Algorithm for") == -1):
-                            lines = lines[32:]
-                            lines = lines.replace("%", "")
-                            if (float(lines) <= 99.5):
-                                num = float(lines)
-                                self.progressBar.setValue(num)
-                            else:
-                                self.bool_temp = True
-            if platform.system() == 'Windows':
-                app_path = GlobalSettings.appdir
-                exe_path = app_path + 'OffTargetFolder\\OT_Win.exe'
-                output_path = '"' + GlobalSettings.CSPR_DB + '\\temp_off.txt" '
-                data_path = '"' + GlobalSettings.CSPR_DB + "\\off_input.txt" + '" '
-            elif platform.system() == 'Linux':
-                app_path = GlobalSettings.appdir.replace('\\', '/')
-                exe_path = app_path + r'OffTargetFolder/OT_Lin'
-                output_path = '"' + GlobalSettings.CSPR_DB + '/temp_off.txt" '
-                data_path = '"' + GlobalSettings.CSPR_DB + "/off_input.txt" + '" '
-            else:
-                app_path = GlobalSettings.appdir.replace('\\', '/')
-                exe_path = app_path + r'OffTargetFolder/OT_Mac'
-                output_path = '"' + GlobalSettings.CSPR_DB + '/temp_off.txt" '
-                data_path = '"' + GlobalSettings.CSPR_DB + "/off_input.txt" + '" '
-            exe_path = '"' + exe_path + '" '
-            cspr_path = '"' + self.cspr_file + '" '
-            db_path = '"' + self.db_file + '" '
-            filename = output_path
-            filename = filename[:len(filename) - 1]
-            filename = filename[1:]
-            filename = filename.replace('"', '')
-            CASPER_info_path = '"' + app_path + 'CASPERinfo' +'" '
-            num_of_mismathes = self.off_max_misMatch
-            tolerance = self.off_tol  # create command string
-            endo = '"' + GlobalSettings.mainWindow.endoChoice.currentText() + '" '
-            detailed_output = " False "
-            avg_output = "True"
-            hsu = ' "' + self.endo_data[GlobalSettings.mainWindow.endoChoice.currentText()][2] + '"'
-            # set the off_target_running to true, to keep the user from closing the window while it is running
-            self.off_target_running = True
-            cmd = exe_path + data_path + endo + cspr_path + db_path + output_path + CASPER_info_path + str(
-                num_of_mismathes) + ' ' + str(tolerance) + detailed_output + avg_output + hsu
-            if platform.system() == 'Windows':
-                cmd = cmd.replace('/', '\\')
-            self.process.readyReadStandardOutput.connect(partial(progUpdate, self.process))
-            self.process.readyReadStandardError.connect(partial(progUpdate, self.process))
-            self.progressBar.setValue(0)
-            QtCore.QTimer.singleShot(100, partial(self.process.start, cmd))
-            self.process.finished.connect(finished)
-        except Exception as e:
-            show_error("Error in get_offTarget_data() in generate library.", e)
-    # submit function
-    # this function takes all of the input from the window, and calls the generate function
-    # Still need to add the checks for 5' seq, and the percentage thing
-    def submit_data(self):
-        try:
-            if self.off_target_running:
-                return
-            output_file = self.output_path.text() + self.filename_input.text()
-            minScore = int(self.minON_comboBox.currentText())
-            num_targets = int(self.numGenescomboBox.currentText())
-            fiveseq = ''
-            # error check for csv files
-            if output_file.endswith('.txt'):
-                output_file = output_file.replace('.txt', '.csv')
-            elif not output_file.endswith('.txt') and not output_file.endswith('.csv'):
-                output_file = output_file + '.csv'
-            # error checking for the space value
-            # if they enter nothing, default to 15 and also make sure it's actually a digit
-            if self.space_line_edit.text() == '':
-                spaceValue = 15
-            elif self.space_line_edit.text().isdigit():
-                spaceValue = int(self.space_line_edit.text())
-            elif not self.space_line_edit.text().isdigit():
-                show_message(
-                    fontSize=12,
-                    icon=QtWidgets.QMessageBox.Icon.Critical,
-                    title="Error",
-                    message="Please enter integers only for space between guides."
-                )
-                return
-            # if space value is more than 200, default to 200
-            if spaceValue > 200:
-                spaceValue = 200
-            elif spaceValue < 0:
-                show_message(
-                    fontSize=12,
-                    icon=QtWidgets.QMessageBox.Icon.Critical,
-                    title="Error",
-                    message="Please enter a space-value that is 0 or greater."
-                )
-                return
-            if self.find_off_Checkbox.isChecked():
-                self.compress_file_off()
-            # get the fiveprimseq data and error check it
-            if self.fiveprimeseq.text() != '' and self.fiveprimeseq.text().isalpha():
-                fiveseq = self.fiveprimeseq.text()
-            elif self.fiveprimeseq.text() != '' and not self.fiveprimeseq.text().isalpha():
-                show_message(
-                    fontSize=12,
-                    icon=QtWidgets.QMessageBox.Icon.Critical,
-                    title="Error",
-                    message="Please make sure only the letters A, T, G, or C are added into 5' End specificity box."
-                )
-                return
-            # get the targeting range data, and error check it here
-            if not self.start_target_range.text().isdigit() or not self.end_target_range.text().isdigit():
-                show_message(
-                    fontSize=12,
-                    icon=QtWidgets.QMessageBox.Icon.Critical,
-                    title="Error",
-                    message="Error: Please make sure that the start and end target ranges are numbers only. Please make sure that start is 0 or greater, and end is 100 or less. "
-                )
-                return
-            elif int(self.start_target_range.text()) >= int(self.end_target_range.text()):
-                show_message(
-                    fontSize=12,
-                    icon=QtWidgets.QMessageBox.Icon.Critical,
-                    title="Error",
-                    message="Please make sure that the start number is always less than the end number"
-                )
-                return
-            # if they check Off-Targeting
-            if self.find_off_Checkbox.isChecked():
-                # make sure its a digit
-                if self.maxOFF_comboBox.text() == '' or not self.maxOFF_comboBox.text().isdigit() and '.' not in self.maxOFF_comboBox.text():
-                    show_message(
-                        fontSize=12,
-                        icon=QtWidgets.QMessageBox.Icon.Critical,
-                        title="Error",
-                        message="Please enter only numbers for Maximum Off-Target Score. It cannot be left blank"
-                    )
-                    return
-                else:
-                    # make sure it between 0 and .5
-                    if not 0.0 < float(self.maxOFF_comboBox.text()) <= .5:
-                        show_message(
-                            fontSize=12,
-                            icon=QtWidgets.QMessageBox.Icon.Critical,
-                            title="Error",
-                            message="Please enter a max off-target score between 0 and 0.5!"
-                        )
-                        return
-                    # compress the data, and then run off-targeting
-                    self.compress_file_off()
-                    self.get_offTarget_data(num_targets, minScore, spaceValue, output_file, fiveseq)
-            else:
-            # actually call the generate function
-                did_work = self.generate(num_targets, minScore, spaceValue, output_file, fiveseq)
-                if did_work != -1:
-                    self.cancel_function()
-                    show_message(
-                        fontSize=12,
-                        icon=QtWidgets.QMessageBox.Icon.Critical,
-                        title="Library Generated!",
-                        message="CASPER has finished generating your library!"
-                    )
-        except Exception as e:
-            show_error("Error in submit_data() in generate library.", e)
-    # clears everything and hides the window
-    def cancel_function(self):
-        try:
-            if self.off_target_running:
-                msgBox = QtWidgets.QMessageBox()
-                msgBox.setStyleSheet("font: " + str(12) + "pt 'Arial'")
-                msgBox.setIcon(QtWidgets.QMessageBox.Icon.Question)
-                msgBox.setWindowTitle("Off-Targeting is running")
-                msgBox.setText(
-                    "Off-Targetting is running. Closing this window will cancel that process, and return to the main window. .\n Do you wish to continue?")
-                msgBox.addButton(QtWidgets.QMessageBox.StandardButton.Yes)
-                msgBox.addButton(QtWidgets.QMessageBox.StandardButton.No)
-                msgBox.exec()
-                if (msgBox.result() == QtWidgets.QMessageBox.No):
-                        return -2
-                else:
-                    self.off_target_running = False
-                    self.process.kill()
-            self.cspr_file = ''
-            self.anno_data = list()
-            self.filename_input.setText('')
-            self.output_path.setText('')
-            self.gen_lib_dict.clear()
-            self.cspr_data.clear()
-            self.Output.clear()
-            self.start_target_range.setText('0')
-            self.end_target_range.setText('100')
-            self.space_line_edit.setText('15')
-            self.find_off_Checkbox.setChecked(False)
-            self.modifyParamscheckBox.setChecked(False)
-            self.maxOFF_comboBox.setText('')
-            self.fiveprimeseq.setText('')
-            self.off_target_running = False
-            self.progressBar.setValue(0)
-            self.hide()
-        except Exception as e:
-            show_error("Error in cancel_function() in generate library.", e)
-    # allows the user to browse for a folder
-    # stores their selection in the output_path line edit
-    def browse_function(self):
-        try:
-            if self.off_target_running:
-                return
-            # get the folder
-            filed = QtWidgets.QFileDialog()
-            mydir = QtWidgets.QFileDialog.getExistingDirectory(filed, "Open a Folder",
-                                                           GlobalSettings.CSPR_DB, QtWidgets.QFileDialog.ShowDirsOnly)
-            if(os.path.isdir(mydir) == False):
-                return
-            # make sure to append the '/' to the folder path
-            if platform.system() == "Windwos":
-                self.output_path.setText(mydir + "\\")
-            else:
-                self.output_path.setText(mydir + "/")
-        except Exception as e:
-            show_error("Error in browse_function() in generate library.", e)
-    # this function builds the dictionary that is used in the generate function
-    # this is the version that builds it from data from feature_table, gbff, or gff
-    # builds it exactly as Brian built it in the files given
-    def build_dict_non_kegg(self):
-        try:
-            for tuple in self.anno_data:
-                chrom = tuple[0]
-                feature = tuple[1]
-                feature_id = get_id(feature)
-                feature_name = get_name(feature)
-                feature_desc = get_description(feature)
-                ### Order: chromosome number, gene start, gene end, dir of gene, gene description, gene name/locus tag
-                self.gen_lib_dict[feature_name] = [chrom,int(feature.location.start),int(feature.location.end),get_strand(feature),get_description(feature),get_name(feature)]
-        except Exception as e:
-            show_error("Error in build_dict_non_kegg() in generate library.", e)
-    # generate function taken from Brian's code
-    def generate(self,num_targets_per_gene, score_limit, space, output_file, fiveseq):
-        try:
-            deletedDict = dict()
-            # check and see if we need to search based on target_range
-            startNum = float(self.start_target_range.text())
-            endNum = float(self.end_target_range.text())
-            checkStartandEndBool = False
-            if startNum != 0.0 or endNum != 100.0:
-                if startNum >= 0.0 and endNum <= 100.0:
-                    startNum = startNum / 100
-                    endNum = endNum / 100
-                    checkStartandEndBool = True
-                else:
-                    show_message(
-                        fontSize=12,
-                        icon=QtWidgets.QMessageBox.Icon.Critical,
-                        title="Invalid Targeting Range:",
-                        message="Please select a targeting range between 0 and 100."
-                    )
-                    return -1
-            for gene in self.gen_lib_dict:
-                target_list = self.cspr_data[gene]  # Gets the gRNAs for given gene
-                #target_list = chrom_list[k:l+1]
-                # Reverse the target list if the gene is on negative strand:
-                if self.gen_lib_dict[gene][3] == "-":
-                    target_list.reverse()
-                # Filter out the guides with low scores and long strings of T's
-                # also store the ones deleted if the user selects 'modify search parameters'
-                if self.modifyParamscheckBox.isChecked():
-                    deletedDict[gene] = list()
-                for i in range(len(target_list) - 1, -1, -1): ### Start at end and move backwards through list
-                    # check the target_range here
-                    if int(target_list[i][3]) < int(score_limit):
-                        if self.modifyParamscheckBox.isChecked():
-                            deletedDict[gene].append(target_list[i])
-                        target_list.pop(i)
-                    # check for gRNAs with poly T regions here
-                    elif re.search("T{5,10}", target_list[i][1]) is not None:
-                        if self.modifyParamscheckBox.isChecked():
-                            deletedDict[gene].append(target_list[i])
-                        target_list.pop(i)
-                # check for the fiveseq
-                if fiveseq != '':
-                    for i in range(len(target_list) - 1, -1, -1): ### Start at end and move backwards through list
-                        if not target_list[i][1].startswith(fiveseq.upper()):
-                            if self.modifyParamscheckBox.isChecked():
-                                deletedDict[gene].append(target_list[i])
-                            target_list.pop(i)
-                # check the target range here
-                if checkStartandEndBool:
-                    for i in range(len(target_list) - 1, -1, -1):
-                        totalDistance = self.gen_lib_dict[gene][2] - self.gen_lib_dict[gene][1]
-                        target_loc = abs(int(target_list[i][0])) - int(self.gen_lib_dict[gene][1])
-                        myRatio = target_loc / totalDistance
-                        if not (startNum <= myRatio <= endNum):
-                            if self.modifyParamscheckBox.isChecked():
-                                deletedDict[gene].append(target_list[i])
-                            target_list.pop(i)
-                # if the user selected off-targeting, check to see that the targets do not exceed the selected max score
-                if self.find_off_Checkbox.isChecked():
-                    maxScore = float(self.maxOFF_comboBox.text())
-                    for i in range(len(target_list) - 1, -1, -1):
-                        if maxScore < float(target_list[i][5]):
-                            if self.modifyParamscheckBox.isChecked():
-                                deletedDict[gene].append(target_list[i])
-                            target_list.pop(i)
-                # Now generating the targets
-                self.Output[gene] = list()
-                i = 0
-                vec_index = 0
-                prev_target = (0, "xyz", 'abc', 1, "-")
-                while i < num_targets_per_gene:
-                    # select the first five targets with the score and space filter that is set in the beginning
-                    if len(target_list) == 0 or vec_index >= len(target_list):
-                        break
-                    while abs(int(target_list[vec_index][0]) - int(prev_target[0])) < int(space):
-                        if target_list[vec_index][3] > prev_target[3] and prev_target != (0,"xyz", "abc", 1, "-"):
-                            self.Output[gene].remove(prev_target)
-                            self.Output[gene].append(target_list[vec_index])
-                            prev_target = target_list[vec_index]
-                        vec_index += 1
-                        # check and see if there will be a indexing error
-                        if vec_index >= len(target_list) - 1:
-                            vec_index = vec_index - 1
-                            break
-                    # Add the new target to the output and add another to i
-                    self.Output[gene].append(target_list[vec_index])
-                    prev_target = target_list[vec_index]
-                    i += 1
-                    vec_index += 1
-            # if the user selects modify search parameters, go through and check to see if each one has the number of targets that the user wanted
-            # if not, append from the deletedDict until they do
-            if self.modifyParamscheckBox.isChecked():
-                for gene in self.Output:
-                    if len(self.Output[gene]) < num_targets_per_gene:
-                        for i in range(len(deletedDict[gene])):
-                            if len(self.Output[gene]) == num_targets_per_gene:
-                                break
-                            else:
-                                loc = deletedDict[gene][i][0]
-                                seq = deletedDict[gene][i][1]
-                                pam = deletedDict[gene][i][2]
-                                score = deletedDict[gene][i][3]
-                                strand = deletedDict[gene][i][4] + '*'
-                                endo = deletedDict[gene][i][5]
-                                self.Output[gene].append((loc, seq, pam, score, strand, endo))
-            # Now output to the file
-            try:
-                f = open(output_file, 'w')
-                # if OT checked
-                if self.find_off_Checkbox.isChecked():
-                    f.write('Gene Name,Sequence,On-Target Score,Off-Target Score,Location,PAM,Strand\n')
-                elif not self.find_off_Checkbox.isChecked():
-                    f.write('Gene Name,Sequence,On-Target Score,Location,PAM,Strand\n')
-                for gene in self.Output:
-                    i = 0
-                    gene_name = self.gen_lib_dict[gene][-1]
-                    for target in self.Output[gene]:
-                        # check to see if the target did not match the user's parameters and they selected 'modify'
-                        # if the target has an error, put 2 asterisks in front of the target sequence
-                        if '*' in target[4]:
-                            tag_id = "**" + gene_name + "-" + str(i + 1)
-                        else:
-                            tag_id = gene_name + "-" + str(i + 1)
-                        i += 1
-                        tag_id = tag_id.replace(',', '')
-                        # if OT checked
-                        if self.find_off_Checkbox.isChecked():
-                            f.write(tag_id + ',' + target[1] + ',' + str(target[3]) + ',' + str(target[5]) + ',' + str(abs(int(target[0]))) + ',' + target[2] + ',' + target[4][0] + '\n')
-                        # if OT not checked
-                        elif not self.find_off_Checkbox.isChecked():
-                            f.write(tag_id + ',' + target[1] + ',' + str(target[3]) + ',' + str(abs(int(target[0]))) + ',' + target[2] + ',' + target[4][0] + '\n')
-                f.close()
-            except PermissionError:
-                show_message(
-                    fontSize=12,
-                    icon=QtWidgets.QMessageBox.Icon.Critical,
-                    title="File Cannot Open",
-                    message="This file cannot be opened. Please make sure that the file is not opened elsewhere and try again."
-                )
-                return -1
-            except Exception as e:
-                print(e)
-                return
-        except Exception as e:
-            show_error("Error in generate() in generate library.", e)

November 1st, 2024

Goal

Hypothesis

Expected Results

Results

Bugs Fixed

Next Steps